Update app.py

app.py

@@ -8,278 +8,291 @@ import fitz  # PyMuPDF
 from PIL import Image
 import io
 
+# Imports for new formats
+from docx import Document
+import openpyxl
+
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.pagesizes import letter
+from reportlab.lib.pagesizes import letter, A4, legal, landscape
 from reportlab.lib.units import inch
 from reportlab.lib import colors
 from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
 
-# --- Configuration ---
+# --- Configuration & Setup ---
 CWD = Path.cwd()
-# Create dedicated directories for clarity
-INPUT_DIR = CWD / "uploaded_files"
-OUTPUT_DIR = CWD / "output_pdfs"
-TEMP_DIR = CWD / "temp_emoji_images"
-FONT_DIR = CWD  # Assumes fonts are in the same directory as the script
+LAYOUTS = {
+    "A4 Portrait": {"size": A4},
+    "A4 Landscape": {"size": landscape(A4)},
+    "Letter Portrait": {"size": letter},
+    "Letter Landscape": {"size": landscape(letter)},
+}
+OUTPUT_DIR = CWD / "generated_outputs"
+PREVIEW_DIR = CWD / "previews"
+FONT_DIR = CWD
 
-# Ensure all directories exist
-for d in [INPUT_DIR, OUTPUT_DIR, TEMP_DIR]:
-    d.mkdir(exist_ok=True)
+# Create necessary directories
+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 the NotoColorEmoji font, which is critical for this process."""
+    """Finds and registers all .ttf files from the app directory."""
     global EMOJI_FONT_PATH
-    print("--- Setting up fonts ---")
+    text_font_names = []
     
-    # Locate the essential NotoColorEmoji font
     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:
-        print("CRITICAL ERROR: 'NotoColorEmoji-Regular.ttf' not found in the application directory.")
-        print("This file is required to render emojis as images. Please add it to the directory.")
-        # Raise an error to stop the app from running in a broken state
-        raise FileNotFoundError("Could not find NotoColorEmoji-Regular.ttf. The application cannot proceed.")
-        
-    # Register a basic font for ReportLab
-    try:
-        pdfmetrics.registerFont(TTFont('DejaVuSans', 'DejaVuSans.ttf'))
-        pdfmetrics.registerFontFamily('DejaVuSans', normal='DejaVuSans', bold='DejaVuSans-Bold', italic='DejaVuSans-Oblique', boldItalic='DejaVuSans-BoldOblique')
-    except:
-        print("Warning: DejaVuSans font not found. Falling back to Helvetica. Please add DejaVuSans.ttf for better Unicode support.")
+        raise FileNotFoundError("CRITICAL: 'NotoColorEmoji-Regular.ttf' not found. This file is required for emoji support.")
+
+    for font_path in FONT_DIR.glob("*.ttf"):
+        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():
+                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:
+        text_font_names.append('Helvetica')
+    return sorted(text_font_names)
 
 def render_emoji_as_image(emoji_char, size_pt):
-    """
-    Takes a single emoji character and renders it as a transparent PNG image in memory.
-    This is the core of the solution to ensure emojis appear in color in any PDF viewer.
-    """
-    if not EMOJI_FONT_PATH:
-        print("Cannot render emoji: Emoji font path not set.")
-        return None
+    """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)]
     
-    # Use a cache to avoid re-rendering the same emoji multiple times
-    if (emoji_char, size_pt) in EMOJI_IMAGE_CACHE:
-        return EMOJI_IMAGE_CACHE[(emoji_char, size_pt)]
-
     try:
-        # Use PyMuPDF (fitz) to draw the emoji onto a temporary, transparent canvas
         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)
-        
-        # Load the color emoji font
         page.insert_font(fontname="emoji", fontfile=EMOJI_FONT_PATH)
-        
-        # Insert the emoji character. The vertical alignment may need tweaking.
         page.insert_text(fitz.Point(0, size_pt * 1.1), emoji_char, fontname="emoji", fontsize=size_pt)
-        
-        # Get a high-resolution PNG of the emoji with a transparent background
         pix = page.get_pixmap(alpha=True, dpi=300)
         doc.close()
-
-        # Save the PNG to an in-memory buffer
         img_buffer = io.BytesIO(pix.tobytes("png"))
         img_buffer.seek(0)
-
-        # Add the buffer to the cache and return it
         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
 
-# --- PDF Generation ---
-def create_pdf_from_markdown(md_filepath: Path):
-    """
-    The main function to convert a single Markdown file into a PDF.
-    It reads the text, processes it line by line, and replaces emojis with images.
-    """
-    print(f"--- Starting PDF conversion for: {md_filepath.name} ---")
-    
-    # Define styles for the PDF document
+# --- 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()
-    # Use a font that supports a wide range of characters, if available
-    body_font = 'DejaVuSans' if 'DejaVuSans' in pdfmetrics.getRegisteredFontNames() else 'Helvetica'
-    style_body = ParagraphStyle('Body', fontName=body_font, fontSize=11, leading=14)
-    style_h1 = ParagraphStyle('H1', fontName=body_font, fontSize=24, leading=28, spaceAfter=12, textColor=colors.darkblue)
-    style_h2 = ParagraphStyle('H2', fontName=body_font, fontSize=18, leading=22, spaceAfter=10)
-    
-    # Regex to find all emojis in a string
+    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)
+
     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):
-        """
-        Splits a line of text into a list of Paragraphs and Images.
-        This allows text and emoji-images to flow together on the same line.
-        """
         parts = emoji_pattern.split(text)
         flowables = []
         for part in parts:
             if not part: continue
-            
             if emoji_pattern.match(part):
-                # This part is an emoji or a sequence of them
                 for emoji_char in part:
                     img_buffer = render_emoji_as_image(emoji_char, style.fontSize)
                     if img_buffer:
-                        # Create an Image object, slightly larger than the text for better spacing
                         img = ReportLabImage(img_buffer, height=style.fontSize * 1.2, width=style.fontSize * 1.2)
                         flowables.append(img)
             else:
-                # This part is plain text
-                flowables.append(Paragraph(part.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;'), style))
-        
-        # Use a Table to keep all parts on the same line. This is a common ReportLab technique.
-        if flowables:
-            return Table([flowables], colWidths=[None] * len(flowables), style=[('VALIGN', (0,0), (-1,-1), 'MIDDLE')])
-        return None
+                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)
 
-    # Read the markdown file
-    try:
-        with open(md_filepath, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-    except Exception as e:
-        print(f"ERROR: Could not read file {md_filepath.name}: {e}")
-        return None
-        
-    # The "story" is ReportLab's list of things to draw in the PDF
-    story = []
-    for line in lines:
-        stripped_line = line.strip()
-        
-        # Simple Markdown parsing
-        if stripped_line.startswith('# '):
-            flowable = text_to_flowables(stripped_line[2:], style_h1)
-        elif stripped_line.startswith('## '):
-            flowable = text_to_flowables(stripped_line[2:], style_h2)
-        elif stripped_line:
-            flowable = text_to_flowables(stripped_line, style_body)
+    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))
         else:
-            flowable = Spacer(1, 0.2 * inch)
-            
-        if flowable:
-            story.append(flowable)
+            story.append(Spacer(1, 0.2*inch))
+    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
 
-    # Generate a unique filename and path for the output PDF
-    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H%M")
-    output_filename = f"{md_filepath.stem}_{timestamp}.pdf"
-    output_filepath = OUTPUT_DIR / output_filename
+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)
 
-    # Build the PDF document
-    doc = SimpleDocTemplate(str(output_filepath), pagesize=letter)
+    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.build(story)
-        print(f"SUCCESS: Successfully created PDF: {output_filename}")
-        return output_filepath
+        doc = fitz.open(pdf_path)
+        page = doc.load_page(0)
+        pix = page.get_pixmap(dpi=150)
+        pix.save(str(preview_path))
+        doc.close()
+        return str(preview_path)
     except Exception as e:
-        print(f"ERROR: Failed to build PDF for {md_filepath.name}. Reason: {e}")
+        print(f"Preview failed for {pdf_path.name}: {e}")
         return None
 
-# --- Gradio UI and Logic ---
-def process_uploads(files):
-    """
-    Takes uploaded files, processes each one into a PDF, and returns a list of generated filepaths.
-    """
-    if not files:
-        raise gr.Error("Please upload at least one Markdown (.md) file.")
-    
-    # Clear caches and temp directories for a clean run
+# --- 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.")
+
+    shutil.rmtree(OUTPUT_DIR, ignore_errors=True); shutil.rmtree(PREVIEW_DIR, ignore_errors=True)
+    OUTPUT_DIR.mkdir(); PREVIEW_DIR.mkdir()
     EMOJI_IMAGE_CACHE.clear()
-    shutil.rmtree(TEMP_DIR, ignore_errors=True); TEMP_DIR.mkdir(exist_ok=True)
-    
-    log_messages = []
-    generated_pdf_paths = []
 
-    for file_obj in files:
-        input_path = Path(file_obj.name)
-        log_messages.append(f"Processing '{input_path.name}'...")
-        
-        # Core PDF creation step
-        output_path = create_pdf_from_markdown(input_path)
+    # Consolidate all markdown content, adding H1 headers between files
+    md_contents = []
+    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
+
+    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')
         
-        if output_path:
-            generated_pdf_paths.append(str(output_path))
-            log_messages.append(f"✅ Success! PDF saved to '{output_path.name}'.")
-        else:
-            log_messages.append(f"❌ Failed to process '{input_path.name}'. Check console for errors.")
+        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)
             
-    # After processing, get the full list of all PDFs in the output directory for the gallery
-    all_pdfs_in_gallery = sorted([str(p) for p in OUTPUT_DIR.glob("*.pdf")], reverse=True)
-    
-    return "\n".join(log_messages), all_pdfs_in_gallery
-
-def refresh_gallery():
-    """Scans the output directory and returns a list of all PDFs found."""
-    return sorted([str(p) for p in OUTPUT_DIR.glob("*.pdf")], reverse=True)
-
-# Main execution block
-if __name__ == "__main__":
-    # This must run once at startup to check for the required font
-    try:
-        setup_fonts()
-    except FileNotFoundError as e:
-        # If the font is missing, we stop the app from launching.
-        print("\n" + "="*60)
-        print(e)
-        print("The application cannot start without this font file.")
-        print("Please add 'NotoColorEmoji-Regular.ttf' and 'DejaVuSans.ttf' to your project directory.")
-        print("="*60)
-        exit() # Stop the script
+            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.")
 
-    # Define the Gradio Interface
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Markdown-to-PDF Alchemist") as demo:
-        gr.Markdown("# 📜 Markdown-to-PDF Alchemist")
-        gr.Markdown("Upload one or more `.md` files. This tool will convert them into PDFs, preserving emojis by rendering them as high-quality images. All generated PDFs will appear in the library below.")
+    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."
+    
+    return gallery_previews, log_message, [str(p) for p in generated_files]
 
-        with gr.Row():
-            with gr.Column(scale=1):
-                upload_button = gr.File(
-                    label="Upload Markdown Files (.md)",
-                    file_count="multiple",
-                    file_types=[".md"],
-                )
-                generate_button = gr.Button("🔮 Alchemize to PDF", variant="primary")
-                log_output = gr.Textbox(label="Alchemist's Log", lines=8, interactive=False)
+# --- 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.Column(scale=2):
-                gr.Markdown("### 📚 Generated PDF Library")
-                # The gallery will show the first page of the PDF as a preview
-                pdf_gallery = gr.Gallery(
-                    label="Generated PDFs",
-                    show_label=False,
-                    elem_id="gallery",
-                    columns=3,
-                    object_fit="contain",
-                    height="auto"
-                )
-                # This button allows manual refreshing of the gallery
-                refresh_button = gr.Button("🔄 Refresh Library")
+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! 🥳")
 
-        # Define the actions when buttons are clicked
-        generate_button.click(
-            fn=process_uploads,
-            inputs=[upload_button],
-            outputs=[log_output, pdf_gallery]
-        )
+    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"])
+            
+            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)
+            
+            generate_btn = gr.Button("🚀 Generate Documents", variant="primary")
         
-        refresh_button.click(
-            fn=refresh_gallery,
-            inputs=None,
-            outputs=[pdf_gallery]
+        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")
+            
+    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]
         )
-        
-        # Load the gallery with existing PDFs when the app starts
-        demo.load(refresh_gallery, None, pdf_gallery)
 
-    # Launch the application
-    demo.launch(debug=True)
+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)