Create app.py

app.py

@@ -0,0 +1,273 @@
+import streamlit as st
+from pathlib import Path
+import base64
+import datetime
+import re
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.pagesizes import letter, A4, legal, landscape
+from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.lib import colors
+
+# --- Configuration & Setup ---
+
+# Define layouts using reportlab's pagesizes
+LAYOUTS = {
+    "A4 Portrait": {"size": A4, "icon": "📄"},
+    "A4 Landscape": {"size": landscape(A4), "icon": "📄"},
+    "Letter Portrait": {"size": letter, "icon": "📄"},
+    "Letter Landscape": {"size": landscape(letter), "icon": "📄"},
+    "Legal Portrait": {"size": legal, "icon": "📄"},
+    "Legal Landscape": {"size": landscape(legal), "icon": "📄"},
+}
+
+# Directory to save the generated PDFs
+OUTPUT_DIR = Path("generated_pdfs")
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+# Path for the required emoji font file
+EMOJI_FONT_PATH = Path("NotoColorEmoji-Regular.ttf")
+
+# Regex to find and wrap emojis for ReportLab
+EMOJI_PATTERN = re.compile(
+    "["
+    "\U0001F600-\U0001F64F"  # emoticons
+    "\U0001F300-\U0001F5FF"  # symbols & pictographs
+    "\U0001F680-\U0001F6FF"  # transport & map symbols
+    "\U0001F700-\U0001F77F"  # alchemical symbols
+    "\U0001F780-\U0001F7FF"  # Geometric Shapes Extended
+    "\U0001F800-\U0001F8FF"  # Supplemental Arrows-C
+    "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
+    "\U0001FA00-\U0001FA6F"  # Chess Symbols
+    "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
+    "\U00002702-\U000027B0"  # Dingbats
+    "\U000024C2-\U0001F251"
+    "]+",
+    flags=re.UNICODE,
+)
+
+# --- Core PDF Generation Class ---
+
+class PDFGenerator:
+    """
+    An object-oriented approach to generating PDFs.
+    Handles font registration, markdown parsing, and PDF creation.
+    """
+    def __init__(self, font_path: Path):
+        """
+        ✨ To start the PDF show, a font we must know.
+        Initializes the generator and registers the necessary emoji font.
+        """
+        self.emoji_font_name = "NotoEmoji"
+        self._register_emoji_font(font_path)
+
+    def _register_emoji_font(self, font_path: Path):
+        """
+        ✍️ Before new fonts can grace the page, first they must be set on stage.
+        Registers the TTF font file with ReportLab if the file exists.
+        """
+        if font_path.exists():
+            pdfmetrics.registerFont(TTFont(self.emoji_font_name, font_path))
+        else:
+            # Provide a helpful error in the web app if the font is missing
+            st.error(f"Emoji font not found at '{font_path}'. Emojis will not be rendered. Please download it.")
+            self.emoji_font_name = "Helvetica" # Fallback to a standard font
+
+    def _wrap_emojis_for_reportlab(self, text: str) -> str:
+        """
+        😀 To make emojis appear so grand, wrap them with a font command.
+        Finds all emojis and wraps them in ReportLab <font> tags.
+        """
+        # If the emoji font failed to register, don't try to use it.
+        if self.emoji_font_name != "NotoEmoji":
+            return text
+            
+        # The lambda function takes each matched emoji (m) and wraps it.
+        return EMOJI_PATTERN.sub(lambda m: f'<font name="{self.emoji_font_name}">{m.group(0)}</font>', text)
+
+    def _markdown_to_story(self, markdown_text: str) -> list:
+        """
+        📜 From markdown text, a simple scrawl, this story builder answers the call.
+        Converts a markdown string 📝 into a list of ReportLab Flowables (a 'story').
+        """
+        styles = getSampleStyleSheet()
+
+        # Define custom styles for different markdown elements
+        style_normal = styles['BodyText']
+        style_h1 = styles['h1']
+        style_h2 = styles['h2']
+        style_h3 = styles['h3']
+        # Use a monospaced font for code blocks
+        style_code = ParagraphStyle('Code', parent=styles['Normal'], fontName='Courier', textColor=colors.darkred)
+
+        story = []
+        lines = markdown_text.split('\n')
+        in_code_block = False
+        code_block_text = ""
+
+        for line in lines:
+            # Handle code blocks (```)
+            if line.strip().startswith("```"):
+                if in_code_block:
+                    story.append(Paragraph(code_block_text, style_code))
+                    in_code_block = False
+                    code_block_text = ""
+                else:
+                    in_code_block = True
+                continue
+
+            if in_code_block:
+                # Escape HTML-sensitive characters and preserve line breaks within code
+                escaped_line = line.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+                code_block_text += escaped_line + '<br/>'
+                continue
+            
+            # This is where we process each line for emojis BEFORE creating a Paragraph
+            processed_line = self._wrap_emojis_for_reportlab(line)
+
+            # Handle markdown syntax
+            if processed_line.startswith("# "):
+                story.append(Paragraph(self._wrap_emojis_for_reportlab(processed_line[2:]), style_h1))
+            elif processed_line.startswith("## "):
+                story.append(Paragraph(self._wrap_emojis_for_reportlab(processed_line[3:]), style_h2))
+            elif processed_line.startswith("### "):
+                story.append(Paragraph(self._wrap_emojis_for_reportlab(processed_line[4:]), style_h3))
+            elif processed_line.strip().startswith(("* ", "- ")):
+                story.append(Paragraph(f"• {self._wrap_emojis_for_reportlab(processed_line.strip()[2:])}", style_normal))
+            elif re.match(r'^\d+\.\s', processed_line.strip()):
+                story.append(Paragraph(processed_line.strip(), style_normal))
+            elif processed_line.strip() == "":
+                story.append(Spacer(1, 0.2 * inch))
+            else:
+                # Handle bold (**) and italics (_) using ReportLab's rich text tags
+                formatted_line = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', processed_line)
+                formatted_line = re.sub(r'_(.*?)_', r'<i>\1</i>', formatted_line)
+                story.append(Paragraph(formatted_line, style_normal))
+        
+        return story
+
+    def create_pdf(self, md_asset: Path, layout_name: str, layout_properties: dict):
+        """
+        📄 With content and a layout's grace, this function builds the PDF space.
+        Creates a single PDF file 📄 from a given markdown file 📝.
+        """
+        try:
+            md_content = md_asset.read_text(encoding="utf-8")
+            
+            date_str = datetime.datetime.now().strftime("%Y-%m-%d")
+            output_filename = f"{md_asset.stem}_{layout_name.replace(' ', '-')}_{date_str}.pdf"
+            output_path = OUTPUT_DIR / output_filename
+
+            # The SimpleDocTemplate handles the page creation and content flow
+            doc = SimpleDocTemplate(
+                str(output_path),
+                pagesize=layout_properties.get("size", A4),
+                rightMargin=inch,
+                leftMargin=inch,
+                topMargin=inch,
+                bottomMargin=inch
+            )
+            
+            story = self._markdown_to_story(md_content)
+            
+            # The .build() method takes the story and renders the PDF
+            doc.build(story)
+            
+        except Exception as e:
+            st.error(f"Failed to process {md_asset.name} with ReportLab: {e}")
+
+
+# --- Streamlit UI and File Handling ---
+
+def get_file_download_link(file_path: Path) -> str:
+    """
+    🔗 To grab your file and not delay, a special link is paved today.
+    Generates a base64-encoded download link for a file.
+    """
+    with open(file_path, "rb") as f:
+        data = base64.b64encode(f.read()).decode()
+    return f'<a href="data:application/octet-stream;base64,{data}" download="{file_path.name}">Download</a>'
+
+def display_file_explorer():
+    """
+    📂 To see your files, both old and new, this handy explorer gives a view.
+    Renders a simple file explorer in the Streamlit app for MD and PDF files.
+    """
+    st.header("📂 File Explorer")
+
+    st.subheader("Source Markdown Files (.md)")
+    md_files = list(Path(".").glob("*.md"))
+    if not md_files:
+        st.info("No Markdown files found. A `sample.md` has been created for you.")
+    else:
+        for md_file in md_files:
+            col1, col2 = st.columns([0.8, 0.2])
+            with col1:
+                st.write(f"📝 `{md_file.name}`")
+            with col2:
+                st.markdown(get_file_download_link(md_file), unsafe_allow_html=True)
+
+    st.subheader("Generated PDF Files")
+    # Sort PDFs by modification time to show the newest first
+    pdf_files = sorted(list(OUTPUT_DIR.glob("*.pdf")), key=lambda p: p.stat().st_mtime, reverse=True)
+    if not pdf_files:
+        st.info("No PDFs generated yet. Click the button above to start.")
+    else:
+        for pdf_file in pdf_files:
+            col1, col2 = st.columns([0.8, 0.2])
+            with col1:
+                st.write(f"📄 `{pdf_file.name}`")
+            with col2:
+                st.markdown(get_file_download_link(pdf_file), unsafe_allow_html=True)
+
+
+# --- Main App Execution ---
+
+def main():
+    """
+    🚀 To run the app and make it go, call this main function, you know!
+    """
+    st.set_page_config(layout="wide", page_title="PDF Generator")
+    st.title("📄 Markdown to PDF Generator")
+    st.markdown("This tool converts all `.md` files in this directory to PDF. It now supports emojis! 👍")
+
+    # Create a sample markdown file if none exist, to help new users.
+    if not list(Path(".").glob("*.md")):
+        with open("sample.md", "w", encoding="utf-8") as f:
+            f.write("# Sample Document 👍\n\nThis is a sample markdown file. **ReportLab** is creating the PDF. Emojis like 🚀 and 💡 should now appear correctly.\n\n### Features\n- Item 1\n- Item 2\n\n```\ndef hello_world():\n    print(\"Hello, PDF! 👋\")\n```\n")
+        st.rerun()
+
+    # Instantiate our generator. It will handle font setup on its own.
+    pdf_generator = PDFGenerator(EMOJI_FONT_PATH)
+
+    if st.button("🚀 Generate PDFs from all Markdown Files", type="primary"):
+        markdown_files = list(Path(".").glob("*.md"))
+        
+        if not markdown_files:
+            st.warning("No `.md` files found. Please add a markdown file to the directory.")
+        else:
+            total_pdfs = len(markdown_files) * len(LAYOUTS)
+            progress_bar = st.progress(0, text="Starting PDF generation...")
+            pdf_count = 0
+
+            with st.spinner("Generating PDFs... Please wait."):
+                for md_file in markdown_files:
+                    st.info(f"Processing: **{md_file.name}**")
+                    for name, properties in LAYOUTS.items():
+                        # Use the instance method to create the PDF
+                        pdf_generator.create_pdf(md_file, name, properties)
+                        pdf_count += 1
+                        progress_bar.progress(pdf_count / total_pdfs, f"Generated {pdf_count}/{total_pdfs} PDFs...")
+            
+            st.success("✅ PDF generation complete!")
+            st.balloons()
+            # Rerun to refresh the file explorer immediately
+            st.rerun()
+
+    display_file_explorer()
+
+
+if __name__ == "__main__":
+    main()