Update app.py

app.py

@@ -6,11 +6,9 @@ import os
 import shutil
 import fitz  # PyMuPDF
 from PIL import Image
+from collections import defaultdict
 import io
-
-# Imports for new formats
-from docx import Document
-import openpyxl
+from pypdf import PdfWriter
 
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
@@ -27,8 +25,10 @@ LAYOUTS = {
     "A4 Landscape": {"size": landscape(A4)},
     "Letter Portrait": {"size": letter},
     "Letter Landscape": {"size": landscape(letter)},
+    "Legal Portrait": {"size": legal},
+    "Legal Landscape": {"size": landscape(legal)},
 }
-OUTPUT_DIR = CWD / "generated_outputs"
+OUTPUT_DIR = CWD / "generated_pdfs"
 PREVIEW_DIR = CWD / "previews"
 FONT_DIR = CWD
 
@@ -36,263 +36,289 @@ FONT_DIR = CWD
 OUTPUT_DIR.mkdir(exist_ok=True)
 PREVIEW_DIR.mkdir(exist_ok=True)
 
+
 # --- Font & Emoji Handling ---
-EMOJI_FONT_PATH = None
-EMOJI_IMAGE_CACHE = {}
 
-def setup_fonts():
-    """Finds and registers all .ttf files from the app directory."""
-    global EMOJI_FONT_PATH
+def register_local_fonts():
+    """Finds and registers all .ttf files from the application's base directory."""
+    print("--- Font Registration Process Starting ---")
     text_font_names = []
+    emoji_font_name = None
     
-    noto_emoji_path = FONT_DIR / "NotoColorEmoji-Regular.ttf"
-    if noto_emoji_path.exists():
-        EMOJI_FONT_PATH = str(noto_emoji_path)
-        print(f"Found emoji font: {EMOJI_FONT_PATH}")
-    else:
-        raise FileNotFoundError("CRITICAL: 'NotoColorEmoji-Regular.ttf' not found. This file is required for emoji support.")
-
-    for font_path in FONT_DIR.glob("*.ttf"):
+    print(f"Scanning for fonts in: {FONT_DIR.absolute()}")
+    font_files = list(FONT_DIR.glob("*.ttf"))
+    print(f"Found {len(font_files)} .ttf files: {[f.name for f in font_files]}")
+
+    for font_path in font_files:
         try:
             font_name = font_path.stem
             pdfmetrics.registerFont(TTFont(font_name, str(font_path)))
-            pdfmetrics.registerFontFamily(font_name, normal=font_name, bold=font_name, italic=font_name, boldItalic=font_name)
-            if "notocoloremoji" not in font_name.lower():
+            pdfmetrics.registerFont(TTFont(f"{font_name}-Bold", str(font_path)))
+            pdfmetrics.registerFont(TTFont(f"{font_name}-Italic", str(font_path)))
+            pdfmetrics.registerFont(TTFont(f"{font_name}-BoldItalic", str(font_path)))
+            pdfmetrics.registerFontFamily(font_name, normal=font_name, bold=f"{font_name}-Bold", italic=f"{font_name}-Italic", boldItalic=f"{font_name}-BoldItalic")
+
+            if "notocoloremoji-regular" in font_name.lower():
+                emoji_font_name = font_name
+            elif "notoemoji" not in font_name.lower(): # Exclude other symbol fonts from text selection
                 text_font_names.append(font_name)
         except Exception as e:
             print(f"Could not register font {font_path.name}: {e}")
 
     if not text_font_names:
+        print("WARNING: No text fonts found. Adding 'Helvetica' as a default.")
         text_font_names.append('Helvetica')
-    return sorted(text_font_names)
 
-def render_emoji_as_image(emoji_char, size_pt):
-    """Renders an emoji character as a PNG image in memory."""
-    if not EMOJI_FONT_PATH: return None
-    if (emoji_char, size_pt) in EMOJI_IMAGE_CACHE: return EMOJI_IMAGE_CACHE[(emoji_char, size_pt)]
-    
-    try:
-        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)
-        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)
-        pix = page.get_pixmap(alpha=True, dpi=300)
-        doc.close()
-        img_buffer = io.BytesIO(pix.tobytes("png"))
-        img_buffer.seek(0)
-        EMOJI_IMAGE_CACHE[(emoji_char, size_pt)] = img_buffer
-        return img_buffer
-    except Exception as e:
-        print(f"ERROR: Could not render emoji '{emoji_char}': {e}")
-        return None
+    print(f"Successfully registered user-selectable fonts: {text_font_names}")
+    print(f"Emoji font set to: {emoji_font_name}")
+    print("--- Font Registration Process Finished ---")
+    return sorted(text_font_names), emoji_font_name
 
-# --- Document Generation Engines ---
-def markdown_to_story(markdown_text: str, font_name: str):
-    """Converts markdown to a ReportLab story, converting emojis to images."""
-    styles = getSampleStyleSheet()
-    style_body = ParagraphStyle('BodyText', fontName=font_name, spaceAfter=6, fontSize=11, leading=14)
-    style_h1 = ParagraphStyle('h1', fontName=font_name, fontSize=24, leading=28, spaceAfter=12, textColor=colors.darkblue)
-    style_h2 = ParagraphStyle('h2', fontName=font_name, fontSize=18, leading=22, spaceAfter=10, textColor=colors.darkslateblue)
+def apply_emoji_font(text: str, emoji_font_name: str) -> str:
+    """
+    Intelligently wraps emoji characters in a <font> tag, preserving existing HTML-like tags.
+    This prevents invalid nested tags like <b><font>...</font></b> which ReportLab handles poorly.
+    """
+    if not emoji_font_name:
+        return text
 
+    # Regex to find emojis
     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))))}]+)")
-
-    def text_to_flowables(text, style):
-        parts = emoji_pattern.split(text)
-        flowables = []
-        for part in parts:
-            if not part: continue
-            if emoji_pattern.match(part):
-                for emoji_char in part:
-                    img_buffer = render_emoji_as_image(emoji_char, style.fontSize)
-                    if img_buffer:
-                        img = ReportLabImage(img_buffer, height=style.fontSize * 1.2, width=style.fontSize * 1.2)
-                        flowables.append(img)
-            else:
-                formatted_part = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', part)
-                flowables.append(Paragraph(formatted_part, style))
-        return Table([flowables], colWidths=[None] * len(flowables), style=[('VALIGN', (0, 0), (-1, -1), 'MIDDLE')]) if flowables else Spacer(0,0)
-
-    story, first_heading = [], True
-    for line in markdown_text.split('\n'):
-        stripped = line.strip()
-        if stripped.startswith("# "):
-            if not first_heading: story.append(PageBreak())
-            story.append(text_to_flowables(stripped[2:], style_h1)); first_heading = False
-        elif stripped.startswith("## "):
-            story.append(text_to_flowables(stripped[3:], style_h2))
-        elif stripped.startswith(("- ", "* ")):
-            story.append(text_to_flowables(stripped[2:], ParagraphStyle(parent=style_body, leftIndent=20, bulletIndent=10)))
-        elif stripped:
-            story.append(text_to_flowables(stripped, style_body))
+                               f"{re.escape(''.join(map(chr, range(0x2600, 0x26ff))))}"
+                               f"{re.escape(''.join(map(chr, range(0x2700, 0x27bf))))}]+)")
+
+    # Regex to split the string by existing tags (<b>, <i>)
+    tag_pattern = re.compile(r"(<[^>]+>)")
+    parts = tag_pattern.split(text)
+    
+    result = []
+    for part in parts:
+        if tag_pattern.match(part):
+            # It's a tag, append it as is
+            result.append(part)
         else:
-            story.append(Spacer(1, 0.2*inch))
+            # It's text, apply emoji font to any emojis within this segment
+            result.append(emoji_pattern.sub(fr'<font name="{emoji_font_name}">\1</font>', part))
+            
+    return "".join(result)
+
+
+# --- PDF Generation & Handling ---
+
+def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str):
+    """
+    Converts markdown to a ReportLab story, with enhanced styling and page breaks.
+    This version correctly separates structural parsing from content formatting.
+    """
+    styles = getSampleStyleSheet()
+    # Define styles for various markdown elements
+    style_normal = ParagraphStyle('BodyText', fontName=font_name, spaceAfter=6, leading=14, fontSize=10)
+    style_h1 = ParagraphStyle('h1', parent=styles['h1'], fontName=font_name, spaceBefore=12, fontSize=24, leading=28, textColor=colors.darkblue)
+    style_h2 = ParagraphStyle('h2', parent=styles['h2'], fontName=font_name, fontSize=18, leading=22, spaceBefore=10)
+    style_h3 = ParagraphStyle('h3', parent=styles['h3'], fontName=font_name, fontSize=14, leading=18, spaceBefore=8)
+    style_code = ParagraphStyle('Code', fontName='Courier', backColor=colors.whitesmoke, textColor=colors.darkred, borderWidth=1, borderColor=colors.lightgrey, padding=8, leading=12, fontSize=9)
+    style_table_header = ParagraphStyle('TableHeader', parent=style_normal, fontName=font_name + "-Bold" if font_name != 'Helvetica' else 'Helvetica-Bold')
+    
+    story = []
+    lines = markdown_text.split('\n')
+    
+    in_code_block, in_table = False, False
+    code_block_text, table_data = "", []
+    first_heading = True
+
+    for line in lines:
+        stripped_line = line.strip()
+
+        if stripped_line.startswith("```"):
+            if in_code_block:
+                story.append(Paragraph(code_block_text.replace('\n', '<br/>'), style_code)); story.append(Spacer(1, 0.1 * inch))
+                in_code_block = False; code_block_text = ""
+            else: in_code_block = True
+            continue
+        if in_code_block:
+            code_block_text += line.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;') + '\n'
+            continue
+        
+        if stripped_line.startswith('|'):
+            if not in_table: in_table = True
+            if all(c in '-|: ' for c in stripped_line): continue
+            cells = [cell.strip() for cell in stripped_line.strip('|').split('|')]
+            table_data.append(cells)
+            continue
+        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 = []
+                for row in table_data[1:]:
+                    formatted_cells = [apply_emoji_font(re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', cell), emoji_font) for cell in row]
+                    formatted_rows.append([Paragraph(cell, style_normal) for cell in formatted_cells])
+                
+                table = Table([header] + formatted_rows, hAlign='LEFT', repeatRows=1)
+                table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), colors.lightgrey), ('GRID', (0, 0), (-1, -1), 1, colors.darkgrey), ('VALIGN', (0,0), (-1,-1), 'MIDDLE')]))
+                story.append(table); story.append(Spacer(1, 0.2 * inch))
+            table_data = []
+
+        if not stripped_line:
+            story.append(Spacer(1, 0.1 * inch))
+            continue
+
+        # Default content is the whole stripped line
+        content = stripped_line
+        style = style_normal
+        extra_args = {}
+        
+        # Detect structural elements and extract the raw content
+        if stripped_line.startswith("# "):
+            if not first_heading: story.append(PageBreak())
+            content = stripped_line.lstrip('# '); style = style_h1; first_heading = False
+        elif stripped_line.startswith("## "):
+            content = stripped_line.lstrip('## '); style = style_h2
+        elif stripped_line.startswith("### "):
+            content = stripped_line.lstrip('### '); style = style_h3
+        elif stripped_line.startswith(("- ", "* ")):
+            content = stripped_line[2:]; extra_args['bulletText'] = '•'
+        
+        # Now, format the extracted content
+        # Apply markdown formatting for bold/italic
+        formatted_content = re.sub(r'_(.*?)_', r'<i>\1</i>', re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', content))
+        # Then apply emoji font to the already formatted line
+        final_content = apply_emoji_font(formatted_content, emoji_font)
+        
+        story.append(Paragraph(final_content, style, **extra_args))
     return story
 
-def create_pdf(md_content, font_name, pagesize, num_columns):
-    """Generates a PDF file from markdown content."""
-    md_buffer = io.BytesIO()
-    story = markdown_to_story(md_content, font_name)
-    if num_columns > 1:
-        doc = BaseDocTemplate(md_buffer, pagesize=pagesize, leftMargin=0.5*inch, rightMargin=0.5*inch, topMargin=0.5*inch, bottomMargin=0.5*inch)
-        frame_width = (doc.width / num_columns) - (num_columns - 1) * 0.1*inch
-        frames = [Frame(doc.leftMargin + i * (frame_width + 0.2*inch), doc.bottomMargin, frame_width, doc.height) for i in range(num_columns)]
-        doc.addPageTemplates([PageTemplate(id='MultiCol', frames=frames)])
-    else:
-        doc = SimpleDocTemplate(md_buffer, pagesize=pagesize)
-    doc.build(story)
-    return md_buffer
-
-def create_docx(md_content):
-    """Generates a DOCX file from markdown content."""
-    document = Document()
-    for line in md_content.split('\n'):
-        line = line.strip()
-        if line.startswith('# '): document.add_heading(line[2:], level=1)
-        elif line.startswith('## '): document.add_heading(line[3:], level=2)
-        elif line.startswith(('- ','* ')): document.add_paragraph(line[2:], style='List Bullet')
-        elif line:
-            p = document.add_paragraph()
-            parts = re.split(r'(\*\*.*?\*\*)', line)
-            for part in parts:
-                if part.startswith('**') and part.endswith('**'):
-                    p.add_run(part[2:-2]).bold = True
-                else:
-                    p.add_run(part)
-    return document
-
-def create_xlsx(md_content):
-    """Generates an XLSX file, splitting content by H1 headers into columns."""
-    workbook = openpyxl.Workbook()
-    sheet = workbook.active
-    sections = re.split(r'\n# ', '\n' + md_content)
-    if not sections[0].strip(): sections.pop(0)
-
-    for c_idx, section in enumerate(sections, 1):
-        lines = section.split('\n')
-        sheet.cell(row=1, column=c_idx, value=lines[0].strip()) # Header
-        for r_idx, line_content in enumerate(lines[1:], 2):
-            sheet.cell(row=r_idx, column=c_idx, value=line_content.strip())
-    return workbook
 
 def create_pdf_preview(pdf_path: Path):
     preview_path = PREVIEW_DIR / f"{pdf_path.stem}.png"
     try:
-        doc = fitz.open(pdf_path)
-        page = doc.load_page(0)
-        pix = page.get_pixmap(dpi=150)
-        pix.save(str(preview_path))
-        doc.close()
+        doc = fitz.open(pdf_path); page = doc.load_page(0); pix = page.get_pixmap()
+        pix.save(str(preview_path)); doc.close()
         return str(preview_path)
     except Exception as e:
-        print(f"Preview failed for {pdf_path.name}: {e}")
-        return None
+        print(f"Could not create preview for {pdf_path.name}: {e}"); return None
 
 # --- Main API Function ---
-def generate_outputs_api(files, output_formats, layouts, fonts, num_columns, progress=gr.Progress(track_tqdm=True)):
-    if not files: raise gr.Error("Please upload at least one Markdown (.md) file.")
-    if not output_formats: raise gr.Error("Please select at least one output format.")
+def generate_pdfs_api(files, layouts, fonts, num_columns, page_w_mult, page_h_mult, progress=gr.Progress(track_tqdm=True)):
+    if not files: raise gr.Error("Please upload at least one Markdown or Image file.")
+    if not layouts: raise gr.Error("Please select at least one page layout.")
+    if not fonts: raise gr.Error("Please select at least one font.")
 
     shutil.rmtree(OUTPUT_DIR, ignore_errors=True); shutil.rmtree(PREVIEW_DIR, ignore_errors=True)
     OUTPUT_DIR.mkdir(); PREVIEW_DIR.mkdir()
-    EMOJI_IMAGE_CACHE.clear()
 
-    # Consolidate all markdown content, adding H1 headers between files
-    md_contents = []
+    grouped_files = defaultdict(lambda: {'md': [], 'img': []})
     for f in files:
-        try:
-            md_contents.append(Path(f.name).read_text(encoding='utf-8'))
-        except Exception as e:
-            print(f"Error reading {f.name}: {e}")
-    md_content = "\n\n# ".join(md_contents)
-    if not md_content.startswith("#"): md_content = "# " + md_content
+        file_path = Path(f.name)
+        stem = file_path.stem.split('_')[0] if '_' in file_path.stem else file_path.stem
+        if file_path.suffix.lower() == '.md': grouped_files[stem]['md'].append(file_path)
+        elif file_path.suffix.lower() in ['.png', '.jpg', '.jpeg']: grouped_files[stem]['img'].append(file_path)
 
-    generated_files = []
-    for format_choice in progress.tqdm(output_formats, desc="Generating Formats"):
-        time_str = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-        
-        try:
-            if format_choice == "PDF":
-                for layout_name in layouts:
-                    for font_name in fonts:
-                        pagesize = LAYOUTS.get(layout_name, {}).get("size", letter)
-                        pdf_buffer = create_pdf(md_content, font_name, pagesize, num_columns)
-                        filename = f"Document_{layout_name.replace(' ','-')}_{font_name}_{time_str}.pdf"
-                        output_path = OUTPUT_DIR / filename
-                        with open(output_path, "wb") as f: f.write(pdf_buffer.getvalue())
-                        generated_files.append(output_path)
-            
-            elif format_choice == "DOCX":
-                docx_doc = create_docx(md_content)
-                filename = f"Document_{time_str}.docx"
-                output_path = OUTPUT_DIR / filename
-                docx_doc.save(output_path)
-                generated_files.append(output_path)
-            
-            elif format_choice == "XLSX":
-                xlsx_book = create_xlsx(md_content)
-                filename = f"Outline_{time_str}.xlsx"
-                output_path = OUTPUT_DIR / filename
-                xlsx_book.save(output_path)
-                generated_files.append(output_path)
-        except Exception as e:
-            print(f"Failed to generate {format_choice}: {e}")
-            gr.Warning(f"Failed to generate {format_choice}. See console for details.")
+    log_updates, generated_pdf_paths = "", []
+
+    for stem, assets in progress.tqdm(grouped_files.items(), desc="Processing File Groups"):
+        for layout_name in layouts:
+            for font_name in fonts:
+                merger = PdfWriter()
+                
+                if assets['md']:
+                    md_content = "\n".join([p.read_text(encoding='utf-8') for p in assets['md']])
+                    md_buffer = io.BytesIO()
+                    story = markdown_to_story(md_content, font_name, EMOJI_FONT_NAME)
+                    
+                    base_w, base_h = LAYOUTS[layout_name]["size"]
+                    pagesize = (base_w * page_w_mult, base_h * page_h_mult)
+                    
+                    if num_columns > 1:
+                        doc = BaseDocTemplate(md_buffer, pagesize=pagesize, leftMargin=0.5*inch, rightMargin=0.5*inch, topMargin=0.5*inch, bottomMargin=0.5*inch)
+                        frame_width = (doc.width / num_columns) - (num_columns - 1) * 0.1*inch
+                        frames = [Frame(doc.leftMargin + i * (frame_width + 0.2*inch), doc.bottomMargin, frame_width, doc.height) for i in range(num_columns)]
+                        doc.addPageTemplates([PageTemplate(id='MultiCol', frames=frames)])
+                    else:
+                        doc = SimpleDocTemplate(md_buffer, pagesize=pagesize)
+                    doc.build(story)
+                    merger.append(fileobj=md_buffer)
 
-    gallery_previews = [p for p in [create_pdf_preview(f) for f in generated_files if f.suffix == '.pdf'] if p]
-    log_message = f"Generated {len(generated_files)} files." if generated_files else "Generation failed. Check logs."
+                for img_path in assets['img']:
+                    with Image.open(img_path) as img: img_width, img_height = img.size
+                    img_buffer = io.BytesIO()
+                    doc = SimpleDocTemplate(img_buffer, pagesize=(img_width, img_height), leftMargin=0, rightMargin=0, topMargin=0, bottomMargin=0)
+                    doc.build([ReportLabImage(img_path, width=img_width, height=img_height)])
+                    merger.append(fileobj=img_buffer)
+                
+                if len(merger.pages) > 0:
+                    time_str = datetime.datetime.now().strftime('%m-%d-%a_%I%M%p').upper()
+                    filename = f"{stem}_{time_str}_{layout_name.replace(' ','-')}_{page_w_mult}x{page_h_mult}_{font_name}_Cols{num_columns}.pdf"
+                    output_path = OUTPUT_DIR / filename
+                    with open(output_path, "wb") as f: merger.write(f)
+                    generated_pdf_paths.append(output_path)
+                    log_updates += f"Generated: {filename}\n"
+
+    gallery_previews = [create_pdf_preview(p) for p in generated_pdf_paths]
+    final_gallery = [g for g in gallery_previews if g is not None]
     
-    return gallery_previews, log_message, [str(p) for p in generated_files]
+    return final_gallery, log_updates, [str(p) for p in generated_pdf_paths]
 
 # --- Gradio UI Definition ---
-try:
-    AVAILABLE_FONTS = setup_fonts()
-except FileNotFoundError as e:
-    print(e)
-    # If font setup fails, we can't run the app.
-    # This prevents Gradio from starting with a fatal error.
-    AVAILABLE_FONTS = []
-
-with gr.Blocks(theme=gr.themes.Soft(), title="Multi-Format Document Generator") as demo:
-    gr.Markdown("# 📄 Multi-Format Document Generator (PDF, DOCX, XLSX)")
-    gr.Markdown("Upload one or more Markdown files (`.md`). The tool will combine them and generate documents in your chosen formats. Emojis in PDFs are fully supported! 🥳")
+AVAILABLE_FONTS, EMOJI_FONT_NAME = register_local_fonts()
+SAMPLE_MARKDOWN = """# Deities Guide: Mythology and Moral Lessons 
+
+1. 📜 **Introduction**
+   - **Purpose**: Explore deities, spirits, saints, and beings with their epic stories and morals!
+   - **Usage**: A guide for learning and storytelling across traditions. ️
+   - **Themes**: Justice ⚖️, faith 🙏, hubris 🏛️, redemption ✨, cosmic order 🌌.
+
+2. 🛠️ **Core Concepts of Divinity**
+   - **Powers**: Creation 🌍, omniscience 👁️‍🗨️, shapeshifting 🦋 across entities.
+   - **Life Cycle**: Mortality ⏳, immortality ♾️, transitions like saints and avatars 🌟.
+   - **Communication**: Omens 🕊️, visions 👁️, miracles ✨ from gods and spirits.
+
+# ⚔️ Arthurian Legends
+ - **Merlin, Morgan le Fay, Arthur**: Mentor 🧙, rival 🧙‍♀️, son 👑.
+ - **Relation**: Family tests loyalty 🤝.
+ - **Lesson**: Honor 🎖️ vs. betrayal 🗡️.
+
+# 🏛️ Greek Mythology
+ - **Zeus, Hera, Athena**: Father ⚡, mother 👑, daughter 🦉.
+ - **Relation**: Family rules with tension 🌩️.
+ - **Lesson**: Hubris  अहंकार meets wisdom 🧠.
+
+# 🕉️ Hindu Trimurti
+ - **Brahma, Vishnu, Shiva**: Creator  Brahma, preserver  Vishnu, destroyer  Shiva.
+ - **Relation**: Divine trio cycles existence 🔄.
+ - **Lesson**: Balance ⚖️ sustains life 💖.
+"""
+with open(CWD / "sample.md", "w", encoding="utf-8") as f: f.write(SAMPLE_MARKDOWN)
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced PDF Generator") as demo:
+    gr.Markdown("# 📄 Advanced PDF Layout Engine")
+    gr.Markdown("Upload Markdown/Image files. The app finds local `.ttf` fonts. Group assets with a common name (e.g., `Doc_part1.md`, `Doc_img1.png`) to combine them. `# Headers` create automatic page breaks.")
 
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### ⚙️ Generation Settings")
-            uploaded_files = gr.File(label="Upload Markdown Files", file_count="multiple", file_types=[".md"])
-            output_formats = gr.CheckboxGroup(choices=["PDF", "DOCX", "XLSX"], label="Select Output Formats", value=["PDF"])
+            uploaded_files = gr.File(label="Upload Markdown & Image Files", file_count="multiple", file_types=[".md", ".png", ".jpg", ".jpeg"])
             
-            with gr.Accordion("PDF Customization", open=True):
-                selected_layouts = gr.CheckboxGroup(choices=list(LAYOUTS.keys()), label="Base Page Layout", value=["Letter Portrait"])
-                selected_fonts = gr.CheckboxGroup(choices=AVAILABLE_FONTS, label="Text Font", value=[AVAILABLE_FONTS[0]] if AVAILABLE_FONTS else [])
-                num_columns_slider = gr.Slider(label="Text Columns (for PDF)", minimum=1, maximum=4, step=1, value=1)
+            with gr.Row():
+                page_w_mult_slider = gr.Slider(label="Page Width Multiplier", minimum=1, maximum=5, step=1, value=1)
+                page_h_mult_slider = gr.Slider(label="Page Height Multiplier", minimum=1, maximum=2, step=1, value=1)
             
-            generate_btn = gr.Button("🚀 Generate Documents", variant="primary")
+            num_columns_slider = gr.Slider(label="Number of Text Columns", minimum=1, maximum=4, step=1, value=1)
+            selected_layouts = gr.CheckboxGroup(choices=list(LAYOUTS.keys()), label="Select Base Page Layout", value=["A4 Portrait"])
+            selected_fonts = gr.CheckboxGroup(choices=AVAILABLE_FONTS, label="Select Text Font", value=[AVAILABLE_FONTS[0]] if AVAILABLE_FONTS else [])
+            generate_btn = gr.Button("🚀 Generate PDFs", variant="primary")
         
         with gr.Column(scale=2):
-            gr.Markdown("### 🖼️ Output Files")
-            gallery_output = gr.Gallery(label="PDF Previews", show_label=False, elem_id="gallery", columns=3, height="auto", object_fit="contain")
-            log_output = gr.Markdown(label="Generation Log", value="Ready...")
-            downloadable_files_output = gr.Files(label="Download Generated Files")
+            gr.Markdown("### 🖼️ PDF Preview Gallery")
+            gallery_output = gr.Gallery(label="Generated PDF Previews", show_label=False, elem_id="gallery", columns=3, height="auto", object_fit="contain")
+            log_output = gr.Markdown(label="Generation Log", value="Logs will appear here...")
+            downloadable_files_output = gr.Files(label="Download Generated PDFs")
             
-    if not AVAILABLE_FONTS:
-        gr.Warning("The application is in a degraded state. Required font files are missing. Please check the console log and add the necessary files.")
-    else:
-        generate_btn.click(
-            fn=generate_outputs_api,
-            inputs=[uploaded_files, output_formats, selected_layouts, selected_fonts, num_columns_slider],
-            outputs=[gallery_output, log_output, downloadable_files_output]
-        )
+    generate_btn.click(fn=generate_pdfs_api, inputs=[uploaded_files, selected_layouts, selected_fonts, num_columns_slider, page_w_mult_slider, page_h_mult_slider], outputs=[gallery_output, log_output, downloadable_files_output])
 
 if __name__ == "__main__":
-    if AVAILABLE_FONTS:
-        demo.launch()
-    else:
-        print("\n" + "="*60)
-        print("Application launch aborted due to missing font files.")
-        print("Please ensure 'NotoColorEmoji-Regular.ttf' is in the project directory.")
-        print("="*60)
+    demo.launch()