Update app.py

app.py

@@ -11,7 +11,7 @@ import io
 from pypdf import PdfWriter
 import random
 
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage, Flowable
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.pagesizes import letter, A4, legal, landscape
 from reportlab.lib.units import inch
@@ -41,16 +41,24 @@ PREVIEW_DIR.mkdir(exist_ok=True)
 
 # --- Font & Emoji Handling ---
 
+# Global cache for rendered emoji images to avoid re-rendering the same emoji
+EMOJI_IMAGE_CACHE = {}
+EMOJI_FONT_PATH = None # Will be set in register_local_fonts
+
 def register_local_fonts():
     """Finds and registers all .ttf files from the application's base directory."""
+    global EMOJI_FONT_PATH
     print("--- Font Registration Process Starting ---")
     text_font_names = []
     emoji_font_name = None
     
     noto_emoji_path = FONT_DIR / "NotoColorEmoji-Regular.ttf"
     if not noto_emoji_path.exists():
-        print(f"Warning: Emoji font not found at {noto_emoji_path}. Emojis may not render correctly.")
-        print("Please download 'NotoColorEmoji-Regular.ttf' and place it in the application directory.")
+        print(f"CRITICAL: Color Emoji font not found at {noto_emoji_path}.")
+        print("Please download 'NotoColorEmoji-Regular.ttf' and place it in the application directory for color emojis to work.")
+    else:
+        EMOJI_FONT_PATH = str(noto_emoji_path)
+
 
     print(f"Scanning for fonts in: {FONT_DIR.absolute()}")
     font_files = list(FONT_DIR.glob("*.ttf"))
@@ -81,24 +89,49 @@ def register_local_fonts():
     print("--- Font Registration Process Finished ---")
     return sorted(text_font_names), emoji_font_name
 
-def apply_emoji_font(text: str, emoji_font_name: str) -> str:
-    """Intelligently wraps emoji characters in a <font> tag to ensure they render correctly."""
-    if not emoji_font_name:
-        return text
-    emoji_pattern = re.compile(f"([{re.escape(''.join(map(chr, range(0x1f600, 0x1f650))))}"
-                               f"{re.escape(''.join(map(chr, range(0x1f300, 0x1f5ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x1f900, 0x1f9ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x2600, 0x26ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x2700, 0x27bf))))}]+)")
-    return emoji_pattern.sub(fr'<font name="{emoji_font_name}">\1</font>', text)
+def render_emoji_as_image(emoji_char, size_pt):
+    """
+    Renders a single emoji character as a transparent PNG image in memory using PyMuPDF.
+    This is the magic to get color emojis into the PDF.
+    """
+    if not EMOJI_FONT_PATH:
+        return None # Cannot render without the font file
+    
+    # Check cache first
+    if (emoji_char, size_pt) in EMOJI_IMAGE_CACHE:
+        return EMOJI_IMAGE_CACHE[(emoji_char, size_pt)]
 
+    try:
+        # Use fitz to draw the emoji with its color font onto a temporary surface
+        rect = fitz.Rect(0, 0, size_pt * 1.5, size_pt * 1.5)
+        doc = fitz.open()
+        page = doc.new_page(width=rect.width, height=rect.height)
+        
+        # Insert the text with the color emoji font
+        page.insert_font(fontname="emoji", fontfile=EMOJI_FONT_PATH)
+        page.insert_text(fitz.Point(0, size_pt * 1.1), emoji_char, fontname="emoji", fontsize=size_pt)
+        
+        # Render to a pixmap (PNG)
+        pix = page.get_pixmap(alpha=True, dpi=300) # High DPI for quality
+        doc.close()
+
+        # Convert to a PIL Image and save to a byte buffer
+        img_buffer = io.BytesIO(pix.tobytes("png"))
+        img_buffer.seek(0)
+
+        # Cache the result
+        EMOJI_IMAGE_CACHE[(emoji_char, size_pt)] = img_buffer
+        return img_buffer
+
+    except Exception as e:
+        print(f"Could not render emoji {emoji_char}: {e}")
+        return None
 
 # --- AI Content Generation (Simulation) ---
 
 def generate_ai_content_api(prompt):
     """
     Simulates a call to an LLM to generate markdown content.
-    In a real application, this would contain `fetch` calls to a generative AI API.
     """
     if not prompt:
         return "# The Golem awaits your command!\n\nPlease enter a prompt in the box above and click '🧠 Animate Golem!' to get started. I can help you write reports, stories, poems, and more! ✨"
@@ -144,17 +177,14 @@ def _draw_header_footer(canvas, doc, header_text, footer_text, title):
     canvas.saveState()
     page_num = canvas.getPageNumber()
     
-    # Replace variables for header and footer. Note: [Total Pages] is only accurate at the end of the build.
     final_footer_text = footer_text.replace("[Page #]", str(page_num)).replace("[Total Pages]", str(doc.page))
     final_header_text = header_text.replace("[Page #]", str(page_num)).replace("[Title]", title)
 
-    # Header
     if final_header_text:
         canvas.setFont('Helvetica', 9)
         canvas.setFillColor(colors.grey)
         canvas.drawRightString(doc.width + doc.leftMargin, doc.height + doc.topMargin + 0.25*inch, final_header_text)
 
-    # Footer
     if final_footer_text:
         canvas.setFont('Helvetica', 9)
         canvas.setFillColor(colors.grey)
@@ -163,7 +193,7 @@ def _draw_header_footer(canvas, doc, header_text, footer_text, title):
     canvas.restoreState()
 
 def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_size_body: int, font_size_h1: int, font_size_h2: int, font_size_h3: int):
-    """Converts markdown to a ReportLab story with enhanced, user-configurable styling."""
+    """Converts markdown to a ReportLab story, turning emojis into inline images for full color support."""
     styles = getSampleStyleSheet()
     
     leading_body = font_size_body * 1.4
@@ -174,6 +204,44 @@ def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_
     style_code = ParagraphStyle('Code', fontName='Courier', backColor=colors.HexColor("#333333"), textColor=colors.HexColor("#f472b6"), borderWidth=1, borderColor=colors.HexColor("#444444"), padding=8, leading=12, fontSize=9)
     style_table_header = ParagraphStyle('TableHeader', parent=style_normal, fontName=f"{font_name}-Bold" if font_name != 'Helvetica' else 'Helvetica-Bold')
 
+    # This regex is the key: it finds and captures all emoji sequences.
+    emoji_pattern = re.compile(f"([{re.escape(''.join(map(chr, range(0x1f600, 0x1f650))))}"
+                               f"{re.escape(''.join(map(chr, range(0x1f300, 0x1f5ff))))}"
+                               f"{re.escape(''.join(map(chr, range(0x1f900, 0x1f9ff))))}"
+                               f"{re.escape(''.join(map(chr, range(0x2600, 0x26ff))))}"
+                               f"{re.escape(''.join(map(chr, range(0x2700, 0x27bf))))}]+)")
+
+    def create_flowables_for_line(text, style):
+        """Splits a line of text into text and emoji images, returning a list of flowables."""
+        parts = emoji_pattern.split(text)
+        flowables = []
+        for part in parts:
+            if not part: continue
+            if emoji_pattern.match(part):
+                # It's an emoji, render it as an image
+                for emoji_char in part: # Render one by one in case they are clumped
+                    img_buffer = render_emoji_as_image(emoji_char, style.fontSize)
+                    if img_buffer:
+                        # Create an image that is sized relative to the font
+                        img = ReportLabImage(img_buffer, height=style.fontSize * 1.2, width=style.fontSize * 1.2)
+                        flowables.append(img)
+            else:
+                # It's regular text, create a Paragraph
+                # Apply markdown for bold/italic within this text segment
+                formatted_part = re.sub(r'_(.*?)_', r'<i>\1</i>', re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', part))
+                flowables.append(Paragraph(formatted_part, style))
+        
+        if not flowables:
+            return [Spacer(0, 0)]
+            
+        # Use a table to keep all flowables on the same line(s)
+        table = Table([flowables], colWidths=[None]*len(flowables))
+        table.setStyle(TableStyle([('VALIGN', (0,0), (-1,-1), 'MIDDLE'),
+                                     ('LEFTPADDING', (0,0), (-1,-1), 0),
+                                     ('RIGHTPADDING', (0,0), (-1,-1), 0),
+                                     ]))
+        return [table]
+
     story = []
     lines = markdown_text.split('\n')
     
@@ -205,18 +273,21 @@ def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_
         if in_table:
             in_table = False
             if table_data:
-                header_content = [apply_emoji_font(re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', cell), emoji_font) for cell in table_data[0]]
-                header = [Paragraph(cell, style_table_header) for cell in header_content]
-                
-                formatted_rows = [
-                    [Paragraph(apply_emoji_font(re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', cell), emoji_font), style_normal) for cell in row]
-                    for row in table_data[1:]
-                ]
-                
-                table = Table([header] + formatted_rows, hAlign='LEFT', repeatRows=1)
+                # Table processing needs to create flowables for each cell
+                processed_table_data = []
+                for row in table_data:
+                    processed_row = [create_flowables_for_line(cell, style_normal)[0] for cell in row]
+                    processed_table_data.append(processed_row)
+
+                # Style header separately
+                header_row = [create_flowables_for_line(cell, style_table_header)[0] for cell in table_data[0]]
+
+                final_table_data = [header_row] + processed_table_data[1:]
+
+                table = Table(final_table_data, hAlign='LEFT', repeatRows=1)
                 table.setStyle(TableStyle([
                     ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor("#4a044e")),
-                    ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                    ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke), # Note: this may not affect paragraphs
                     ('GRID', (0, 0), (-1, -1), 1, colors.HexColor("#6b21a8")),
                     ('VALIGN', (0,0), (-1,-1), 'MIDDLE'),
                     ('TOPPADDING', (0,0), (-1,-1), 6),
@@ -224,10 +295,12 @@ def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_
                 ]))
                 story.append(table); story.append(Spacer(1, 0.2 * inch))
             table_data = []
+            continue
+
 
         if not stripped_line: continue
 
-        content, style, extra_args = stripped_line, style_normal, {}
+        content, style, bullet_text = stripped_line, style_normal, None
         
         if stripped_line.startswith("# "):
             if not first_heading: story.append(PageBreak())
@@ -236,11 +309,21 @@ def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_
             first_heading = False
         elif stripped_line.startswith("## "): content, style = stripped_line.lstrip('## '), style_h2
         elif stripped_line.startswith("### "): content, style = stripped_line.lstrip('### '), style_h3
-        elif stripped_line.startswith(("- ", "* ")): content, extra_args['bulletText'] = stripped_line[2:], '•'
+        elif stripped_line.startswith(("- ", "* ")): 
+            content = stripped_line[2:]
+            bullet_text = '•      ' # Using spaces for indentation
         
-        formatted_content = re.sub(r'_(.*?)_', r'<i>\1</i>', re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', content))
-        final_content = apply_emoji_font(formatted_content, emoji_font)
-        story.append(Paragraph(final_content, style, **extra_args))
+        # Now, process the content into flowables (text + emoji images)
+        line_flowables = create_flowables_for_line(content, style)
+
+        if bullet_text:
+            # For lists, put the bullet and the content table in another table
+            bullet_p = Paragraph(bullet_text, style)
+            list_item_table = Table([[bullet_p] + line_flowables], colWidths=[style.fontSize*1.5] + [None]*len(line_flowables))
+            list_item_table.setStyle(TableStyle([('VALIGN', (0,0), (-1,-1), 'TOP'), ('LEFTPADDING', (0,0), (-1,-1), 0), ('RIGHTPADDING', (0,0), (-1,-1), 0)]))
+            story.append(list_item_table)
+        else:
+            story.extend(line_flowables)
         
     return story, document_title
 
@@ -267,6 +350,7 @@ def generate_pdfs_api(files, ai_content, layouts, fonts, num_columns, header_tex
     if not files and not ai_content.strip(): raise gr.Error("Please conjure some content or upload an image before alchemizing!")
     if not layouts: raise gr.Error("You must select a scroll (page layout)!")
     if not fonts: raise gr.Error("A scribe needs a font! Please choose one.")
+    if not EMOJI_FONT_PATH: raise gr.Error("CRITICAL: Cannot generate PDFs. 'NotoColorEmoji-Regular.ttf' not found. Please add it to the app directory.")
 
     shutil.rmtree(OUTPUT_DIR, ignore_errors=True); shutil.rmtree(PREVIEW_DIR, ignore_errors=True)
     OUTPUT_DIR.mkdir(); PREVIEW_DIR.mkdir()
@@ -276,6 +360,9 @@ def generate_pdfs_api(files, ai_content, layouts, fonts, num_columns, header_tex
 
     log_updates, generated_pdf_paths = "", []
     
+    # Clear emoji cache for each run to save memory
+    EMOJI_IMAGE_CACHE.clear()
+
     for layout_name in progress.tqdm(layouts, desc=" brewing potions..."):
         for font_name in progress.tqdm(fonts, desc=f" enchanting scrolls with {layout_name}..."):
             merger = PdfWriter()
@@ -424,8 +511,9 @@ with gr.Blocks(theme=theme, title="The PDF Alchemist") as demo:
 if __name__ == "__main__":
     if not (FONT_DIR / "NotoColorEmoji-Regular.ttf").exists():
         print("\n" + "="*80)
-        print("WARNING: 'NotoColorEmoji-Regular.ttf' not found.")
+        print("CRITICAL WARNING: 'NotoColorEmoji-Regular.ttf' not found.")
         print("Please download it from Google Fonts and place it in the script's directory for emojis to render correctly.")
+        print("The application will fail to generate PDFs without it.")
         print("="*80 + "\n")
     if not any("MedievalSharp" in s for s in AVAILABLE_FONTS):
         print("\n" + "="*80)