Update app.py

app.py

@@ -1,711 +1,184 @@
-import io
-import os
-import re
-import glob
-import textwrap
 import streamlit as st
-import pandas as pd
-import mistune
-import fitz
-import edge_tts
-import asyncio
-import base64
-
-from datetime import datetime
 from pathlib import Path
-from PIL import Image
-from reportlab.pdfgen import canvas
-from reportlab.lib.pagesizes import letter, A4, legal, A3, A5, LETTER, LEGAL
-from reportlab.lib.utils import ImageReader
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image as ReportLabImage
+import base64
+import datetime
+import re
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+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
-from urllib.parse import quote
 
-# Page config
-st.set_page_config(page_title="PDF & Code Interpreter", layout="wide", page_icon="🚀")
+# --- Configuration & Setup ---
 
-def delete_asset(path):
-    try:
-        os.remove(path)
-    except Exception as e:
-        st.error(f"Error deleting file: {e}")
-    st.rerun()
+# Define layouts using reportlab's pagesizes
+# The 'size' key now holds a tuple (width, height)
+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": "📄"},
+}
 
-async def generate_audio(text, voice, filename):
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(filename)
-    return filename
+# Directory to save the generated PDFs
+OUTPUT_DIR = Path("generated_pdfs")
+OUTPUT_DIR.mkdir(exist_ok=True)
 
-def clean_for_speech(text):
-    text = text.replace("#", "")
-    emoji_pattern = re.compile(
-        r"[\U0001F300-\U0001F5FF"
-        r"\U0001F600-\U0001F64F"
-        r"\U0001F680-\U0001F6FF"
-        r"\U0001F700-\U0001F77F"
-        r"\U0001F780-\U0001F7FF"
-        r"\U0001F800-\U0001F8FF"
-        r"\U0001F900-\U0001F9FF"
-        r"\U0001FA00-\U0001FA6F"
-        r"\U0001FA70-\U0001FAFF"
-        r"\u2600-\u26FF"
-        r"\u2700-\u27BF]+", flags=re.UNICODE)
-    return emoji_pattern.sub('', text)
+# --- ReportLab PDF Generation ---
 
-def detect_and_convert_links(text):
-    md_link_pattern = re.compile(r'\[(.*?)\]\((https?://[^\s\[\]()<>{}]+)\)')
-    text = md_link_pattern.sub(r'<a href="\2" color="blue">\1</a>', text)
-    url_pattern = re.compile(r'(?<!href=")(https?://[^\s<>{}]+)', re.IGNORECASE)
-    text = url_pattern.sub(r'<a href="\1" color="blue">\1</a>', text)
-    return text
-
-def apply_emoji_font(text, emoji_font):
-    tag_pattern = re.compile(r'(<[^>]+>)')
-    segments = tag_pattern.split(text)
-    result = []
-    emoji_pattern = re.compile(
-        r"([\U0001F300-\U0001F5FF"
-        r"\U0001F600-\U0001F64F"
-        r"\U0001F680-\U0001F6FF"
-        r"\U0001F700-\U0001F77F"
-        r"\U0001F780-\U0001F7FF"
-        r"\U0001F800-\U0001F8FF"
-        r"\U0001F900-\U0001F9FF"
-        r"\U0001FAD0-\U0001FAD9"
-        r"\U0001FA00-\U0001FA6F"
-        r"\U0001FA70-\U0001FAFF"
-        r"\u2600-\u26FF"
-        r"\u2700-\u27BF]+)"
-    )
-    def replace_emoji(match):
-        emoji = match.group(1)
-        return f'<font face="{emoji_font}">{emoji}</font>'
-    for segment in segments:
-        if tag_pattern.match(segment):
-            result.append(segment)
-        else:
-            parts = []
-            last_pos = 0
-            for match in emoji_pattern.finditer(segment):
-                start, end = match.span()
-                if last_pos < start:
-                    parts.append(f'<font face="DejaVuSans">{segment[last_pos:start]}</font>')
-                parts.append(replace_emoji(match))
-                last_pos = end
-            if last_pos < len(segment):
-                parts.append(f'<font face="DejaVuSans">{segment[last_pos:]}</font>')
-            result.append(''.join(parts))
-    return ''.join(result)
+def markdown_to_story(markdown_text: str):
+    """Converts a markdown string into a list of ReportLab Flowables (a 'story')."""
+    styles = getSampleStyleSheet()
+    
+    # Define custom styles
+    style_normal = styles['BodyText']
+    style_h1 = styles['h1']
+    style_h2 = styles['h2']
+    style_h3 = styles['h3']
+    style_code = styles['Code']
+    
+    # A simple regex-based parser for markdown
+    story = []
+    lines = markdown_text.split('\n')
+    
+    in_code_block = False
+    code_block_text = ""
 
-def markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_to_fonts):
-    lines = markdown_text.strip().split('\n')
-    pdf_content = []
-    number_pattern = re.compile(r'^\d+(\.\d+)*\.\s')
-    heading_pattern = re.compile(r'^(#{1,4})\s+(.+)$')
-    first_numbered_seen = False
     for line in lines:
-        line = line.strip()
-        if not line:
+        if line.strip().startswith("```"):
+            if in_code_block:
+                story.append(Paragraph(code_block_text.replace('\n', '<br/>'), style_code))
+                in_code_block = False
+                code_block_text = ""
+            else:
+                in_code_block = True
             continue
-        if headings_to_fonts and line.startswith('#'):
-            heading_match = heading_pattern.match(line)
-            if heading_match:
-                level = len(heading_match.group(1))
-                heading_text = heading_match.group(2).strip()
-                formatted_heading = f"<h{level}>{heading_text}</h{level}>"
-                pdf_content.append(formatted_heading)
-                continue
-        is_numbered_line = number_pattern.match(line) is not None
-        if add_space_before_numbered and is_numbered_line:
-            if first_numbered_seen and not line.startswith("1."):
-                pdf_content.append("")
-            if not first_numbered_seen:
-                first_numbered_seen = True
-        line = detect_and_convert_links(line)
-        line = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', line)
-        line = re.sub(r'\*([^*]+?)\*', r'<b>\1</b>', line)
-        pdf_content.append(line)
-    total_lines = len(pdf_content)
-    return pdf_content, total_lines
 
-def create_pdf(markdown_texts, image_files, base_font_size=14, num_columns=2, add_space_before_numbered=True, headings_to_fonts=True, doc_title="Combined Document", page_size=A4):
-    if not markdown_texts and not image_files:
-        return None
-    buffer = io.BytesIO()
-    
-    # Use the selected page size
-    if page_size == "A4":
-        page_dimensions = A4
-    elif page_size == "Letter":
-        page_dimensions = letter
-    elif page_size == "Legal":
-        page_dimensions = legal
-    elif page_size == "A3":
-        page_dimensions = A3
-    elif page_size == "A5":
-        page_dimensions = A5
-    else:
-        page_dimensions = A4  # Default fallback
-        
-    page_width = page_dimensions[0] * 2
-    page_height = page_dimensions[1]
-    
-    doc = SimpleDocTemplate(
-        buffer,
-        pagesize=(page_width, page_height),
-        leftMargin=36,
-        rightMargin=36,
-        topMargin=36,
-        bottomMargin=36,
-        title=doc_title
-    )
-    styles = getSampleStyleSheet()
-    spacer_height = 10
-    try:
-        pdfmetrics.registerFont(TTFont("DejaVuSans", "DejaVuSans.ttf"))
-        pdfmetrics.registerFont(TTFont("NotoEmoji-Bold", "NotoEmoji-Bold.ttf"))
-    except Exception as e:
-        st.error(f"Font registration error: {e}")
-        return None
-    story = []
-    for markdown_text in markdown_texts:
-        pdf_content, total_lines = markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_to_fonts)
-        total_chars = sum(len(line) for line in pdf_content)
-        hierarchy_weight = sum(1.5 if line.startswith("<b>") else 1 for line in pdf_content)
-        longest_line_words = max(len(line.split()) for line in pdf_content) if pdf_content else 0
-        content_density = total_lines * hierarchy_weight + total_chars / 50
-        usable_height = page_height - 72 - spacer_height
-        usable_width = page_width - 72
-        avg_line_chars = total_chars / total_lines if total_lines > 0 else 50
-        col_width = usable_width / num_columns
-        min_font_size = 5
-        max_font_size = 16
-        lines_per_col = total_lines / num_columns if num_columns > 0 else total_lines
-        target_height_per_line = usable_height / lines_per_col if lines_per_col > 0 else usable_height
-        estimated_font_size = int(target_height_per_line / 1.5)
-        adjusted_font_size = max(min_font_size, min(max_font_size, estimated_font_size))
-        if avg_line_chars > col_width / adjusted_font_size * 10:
-            adjusted_font_size = int(col_width / (avg_line_chars / 10))
-            adjusted_font_size = max(min_font_size, adjusted_font_size)
-        if longest_line_words > 17 or lines_per_col > 20:
-            font_scale = min(17 / max(longest_line_words, 17), 60 / max(lines_per_col, 20))
-            adjusted_font_size = max(min_font_size, int(base_font_size * font_scale))
-        item_style = ParagraphStyle(
-            'ItemStyle', parent=styles['Normal'], fontName="DejaVuSans",
-            fontSize=adjusted_font_size, leading=adjusted_font_size * 1.15, spaceAfter=1,
-            linkUnderline=True
-        )
-        numbered_bold_style = ParagraphStyle(
-            'NumberedBoldStyle', parent=styles['Normal'], fontName="NotoEmoji-Bold",
-            fontSize=adjusted_font_size, leading=adjusted_font_size * 1.15, spaceAfter=1,
-            linkUnderline=True
-        )
-        section_style = ParagraphStyle(
-            'SectionStyle', parent=styles['Heading2'], fontName="DejaVuSans",
-            textColor=colors.darkblue, fontSize=adjusted_font_size * 1.1, leading=adjusted_font_size * 1.32, spaceAfter=2,
-            linkUnderline=True
-        )
-        columns = [[] for _ in range(num_columns)]
-        lines_per_column = total_lines / num_columns if num_columns > 0 else total_lines
-        current_line_count = 0
-        current_column = 0
-        number_pattern = re.compile(r'^\d+(\.\d+)*\.\s')
-        for item in pdf_content:
-            if current_line_count >= lines_per_column and current_column < num_columns - 1:
-                current_column += 1
-                current_line_count = 0
-            columns[current_column].append(item)
-            current_line_count += 1
-        column_cells = [[] for _ in range(num_columns)]
-        for col_idx, column in enumerate(columns):
-            for item in column:
-                if isinstance(item, str):
-                    heading_match = re.match(r'<h(\d)>(.*?)</h\1>', item) if headings_to_fonts else None
-                    if heading_match:
-                        level = int(heading_match.group(1))
-                        heading_text = heading_match.group(2)
-                        heading_style = ParagraphStyle(
-                            f'Heading{level}Style',
-                            parent=styles['Heading1'],
-                            fontName="DejaVuSans",
-                            textColor=colors.darkblue if level == 1 else (colors.black if level > 2 else colors.blue),
-                            fontSize=adjusted_font_size * (1.6 - (level-1)*0.15),
-                            leading=adjusted_font_size * (1.8 - (level-1)*0.15),
-                            spaceAfter=4 - (level-1),
-                            spaceBefore=6 - (level-1),
-                            linkUnderline=True
-                        )
-                        column_cells[col_idx].append(Paragraph(apply_emoji_font(heading_text, "NotoEmoji-Bold"), heading_style))
-                    elif item.startswith("<b>") and item.endswith("</b>"):
-                        content = item[3:-4].strip()
-                        if number_pattern.match(content):
-                            column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), numbered_bold_style))
-                        else:
-                            column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), section_style))
-                    else:
-                        column_cells[col_idx].append(Paragraph(apply_emoji_font(item, "NotoEmoji-Bold"), item_style))
-                else:
-                    column_cells[col_idx].append(Paragraph(apply_emoji_font(str(item), "NotoEmoji-Bold"), item_style))
-        max_cells = max(len(cells) for cells in column_cells) if column_cells else 0
-        for cells in column_cells:
-            cells.extend([Paragraph("", item_style)] * (max_cells - len(cells)))
-        table_data = list(zip(*column_cells)) if column_cells else [[]]
-        table = Table(table_data, colWidths=[col_width] * num_columns, hAlign='CENTER')
-        table.setStyle(TableStyle([
-            ('VALIGN', (0, 0), (-1, -1), 'TOP'),
-            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
-            ('BACKGROUND', (0, 0), (-1, -1), colors.white),
-            ('GRID', (0, 0), (-1, -1), 0, colors.white),
-            ('LINEAFTER', (0, 0), (num_columns-1, -1), 0.5, colors.grey),
-            ('LEFTPADDING', (0, 0), (-1, -1), 2),
-            ('RIGHTPADDING', (0, 0), (-1, -1), 2),
-            ('TOPPADDING', (0, 0), (-1, -1), 1),
-            ('BOTTOMPADDING', (0, 0), (-1, -1), 1),
-        ]))
-        story.append(Spacer(1, spacer_height))
-        story.append(table)
-        story.append(Spacer(1, spacer_height * 2))
-    for img_path in image_files:
-        try:
-            img = Image.open(img_path)
-            img_width, img_height = img.size
-            page_width_img, page_height_img = page_dimensions
-            scale = min((page_width_img - 40) / img_width, (page_height_img - 40) / img_height)
-            new_width = img_width * scale
-            new_height = img_height * scale
-            story.append(ReportLabImage(img_path, width=new_width, height=new_height))
-            story.append(Spacer(1, spacer_height))
-        except Exception as e:
-            st.warning(f"Could not process image {img_path}: {e}")
+        if in_code_block:
+            # Escape HTML tags for code blocks
+            escaped_line = line.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+            code_block_text += escaped_line + '\n'
             continue
-    doc.build(story)
-    buffer.seek(0)
-    return buffer.getvalue()
 
-def pdf_to_image(pdf_bytes):
-    if pdf_bytes is None:
-        return None
-    try:
-        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
-        images = []
-        for page in doc:
-            pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
-            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-            images.append(img)
-        doc.close()
-        return images
-    except Exception as e:
-        st.error(f"Failed to render PDF preview: {e}")
-        return None
+        if line.startswith("# "):
+            story.append(Paragraph(line[2:], style_h1))
+        elif line.startswith("## "):
+            story.append(Paragraph(line[3:], style_h2))
+        elif line.startswith("### "):
+            story.append(Paragraph(line[4:], style_h3))
+        elif line.strip().startswith(("* ", "- ")):
+            # Handle bullet points
+            story.append(Paragraph(f"• {line.strip()[2:]}", style_normal, bulletText='•'))
+        elif re.match(r'^\d+\.\s', line.strip()):
+            # Handle numbered lists
+            story.append(Paragraph(line.strip(), style_normal))
+        elif line.strip() == "":
+            story.append(Spacer(1, 0.2 * inch))
+        else:
+            # Handle bold and italics
+            line = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', line)
+            line = re.sub(r'_(.*?)_', r'<i>\1</i>', line)
+            story.append(Paragraph(line, style_normal))
+            
+    return story
 
-def get_video_html(video_path, width="100%"):
+def create_pdf_with_reportlab(md_path: Path, layout_name: str, layout_properties: dict):
+    """Creates a PDF for a given markdown file and layout."""
     try:
-        video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
-        return f'''
-        <video width="{width}" controls autoplay muted loop>
-            <source src="{video_url}" type="video/mp4">
-            Your browser does not support the video tag.
-        </video>
-        '''
-    except Exception as e:
-        st.warning(f"Could not load video {video_path}: {e}")
-        return ""
-
-def display_glossary_entity(k):
-    search_urls = {
-        "🚀🌌ArXiv": lambda k: f"https://arxiv.org/search/?query={quote(k)}&searchtype=all",
-        "📖": lambda k: f"https://en.wikipedia.org/wiki/{quote(k)}",
-        "🔍": lambda k: f"https://www.google.com/search?q={quote(k)}",
-        "🎥": lambda k: f"https://www.youtube.com/results?search_query={quote(k)}",
-    }
-    links_md = ' '.join([f"[{emoji}]({url(k)})" for emoji, url in search_urls.items()])
-    st.markdown(f"**{k}** <small>{links_md}</small>", unsafe_allow_html=True)
-
-# Tabs setup
-tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"])
-
-with tab1:
-    st.header("📄 PDF Composer & Voice Generator 🚀")
-    
-    # Sidebar PDF settings
-    with st.sidebar:
-        st.subheader("📄 PDF Settings")
-        columns = st.slider("Text columns", 1, 3, 2)
-        font_family = st.selectbox("Font", ["Helvetica", "Times-Roman", "Courier", "DejaVuSans"])
-        font_size = st.slider("Font size", 6, 24, 14)
+        md_content = md_path.read_text(encoding="utf-8")
         
-        # Page size selection
-        page_size_options = {
-            "A4 (210 × 297 mm)": "A4",
-            "Letter (8.5 × 11 in)": "Letter", 
-            "Legal (8.5 × 14 in)": "Legal",
-            "A3 (297 × 420 mm)": "A3",
-            "A5 (148 × 210 mm)": "A5"
-        }
-        selected_page_size = st.selectbox(
-            "📏 Page Size", 
-            options=list(page_size_options.keys()),
-            index=0  # Default to A4
+        date_str = datetime.datetime.now().strftime("%Y-%m-%d")
+        output_filename = f"{md_path.stem}_{layout_name.replace(' ', '-')}_{date_str}.pdf"
+        output_path = OUTPUT_DIR / output_filename
+
+        doc = SimpleDocTemplate(
+            str(output_path),
+            pagesize=layout_properties.get("size", A4),
+            rightMargin=inch,
+            leftMargin=inch,
+            topMargin=inch,
+            bottomMargin=inch
         )
-        page_size = page_size_options[selected_page_size]
-    
-    # Multiple markdown file upload
-    md_files = st.file_uploader("Upload Markdown Files (.md)", type=["md"], accept_multiple_files=True)
-    markdown_texts = []
-    combined_text = ""
-    
-    if md_files:
-        st.subheader(f"📂 Uploaded Files ({len(md_files)})")
-        for i, md_file in enumerate(md_files):
-            md_text = md_file.getvalue().decode("utf-8")
-            markdown_texts.append(md_text)
-            combined_text += md_text + "\n\n"
-            
-            with st.expander(f"📄 {md_file.name}"):
-                st.markdown(md_text[:500] + "..." if len(md_text) > 500 else md_text)
         
-        stem = f"combined_{len(md_files)}_files_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-    else:
-        # Single text area for manual input
-        manual_text = st.text_area("Or enter markdown text directly", height=200)
-        if manual_text:
-            markdown_texts = [manual_text]
-            combined_text = manual_text
-        stem = datetime.now().strftime('%Y%m%d_%H%M%S')
-    
-    # Convert Markdown to plain text for voice generation
-    if combined_text:
-        renderer = mistune.HTMLRenderer()
-        markdown = mistune.create_markdown(renderer=renderer)
-        html = markdown(combined_text)
-        plain_text = re.sub(r'<[^>]+>', '', html)
+        story = markdown_to_story(md_content)
         
-        st.subheader("📊 Content Summary")
-        col1, col2, col3, col4 = st.columns(4)
-        with col1:
-            st.metric("Files", len(md_files) if md_files else 1)
-        with col2:
-            st.metric("Total Characters", len(combined_text))
-        with col3:
-            st.metric("Estimated Words", len(combined_text.split()))
-        with col4:
-            st.metric("Page Size", selected_page_size.split(" (")[0])
-    else:
-        plain_text = ""
-    
-    # Voice settings
-    st.subheader("🔊 Text-to-Speech Settings")
-    col1, col2 = st.columns(2)
-    with col1:
-        languages = {"English (US)": "en", "English (UK)": "en-uk", "Spanish": "es"}
-        voice_choice = st.selectbox("Voice Language", list(languages.keys()))
-        voice_lang = languages[voice_choice]
-        slow = st.checkbox("Slow Speech")
-    
-    with col2:
-        VOICES = ["en-US-AriaNeural", "en-US-JennyNeural", "en-GB-SoniaNeural", "en-US-GuyNeural", "en-US-AnaNeural"]
-        selected_voice = st.selectbox("Select Voice for TTS", options=VOICES, index=0)
-    
-    if st.button("🔊 Generate & Download Voice MP3 from Text"):
-        if plain_text.strip():
-            voice_file = f"{stem}_{selected_voice}.mp3"
-            try:
-                with st.spinner("Generating audio..."):
-                    cleaned_text = clean_for_speech(plain_text)
-                    audio_file = asyncio.run(generate_audio(cleaned_text, selected_voice, voice_file))
-                st.success("Audio generated successfully!")
-                st.audio(audio_file)
-                with open(audio_file, 'rb') as mp3:
-                    st.download_button("📥 Download MP3", data=mp3, file_name=voice_file, mime="audio/mpeg")
-            except Exception as e:
-                st.error(f"Error generating voice: {e}")
-        else:
-            st.warning("No text to generate voice from.")
-    
-    # Image uploads and ordering
-    st.subheader("🖼️ Image Management")
-    imgs = st.file_uploader("Upload Images for PDF", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
-    ordered_images = []
-    if imgs:
-        st.write(f"📊 Uploaded {len(imgs)} images")
-        df_imgs = pd.DataFrame([{"name": f.name, "order": i} for i, f in enumerate(imgs)])
-        edited = st.data_editor(df_imgs, use_container_width=True, num_rows="dynamic")
-        for _, row in edited.sort_values("order").iterrows():
-            for f in imgs:
-                if f.name == row['name']:
-                    ordered_images.append(f)
-                    break
-    
-    # PDF Generation
-    st.subheader("📄 PDF Generation")
-    
-    if st.button("🖋️ Generate PDF with Markdown & Images", type="primary"):
-        if not markdown_texts and not ordered_images:
-            st.warning("Please provide some markdown text or upload images to generate a PDF.")
-        else:
-            with st.spinner(f"Generating PDF with {page_size} page size..."):
-                if markdown_texts and not ordered_images:
-                    # Use the enhanced create_pdf function
-                    pdf_bytes = create_pdf(
-                        markdown_texts=markdown_texts,
-                        image_files=[],
-                        base_font_size=font_size,
-                        num_columns=columns,
-                        add_space_before_numbered=True,
-                        headings_to_fonts=True,
-                        doc_title=f"Markdown_Document_{len(markdown_texts)}_files",
-                        page_size=page_size
-                    )
-                    
-                    if pdf_bytes:
-                        pdf_images = pdf_to_image(pdf_bytes)
-                        if pdf_images:
-                            st.subheader("Preview of Generated PDF")
-                            for i, img in enumerate(pdf_images):
-                                st.image(img, caption=f"Page {i+1}", use_container_width=True)
-                        
-                        pdf_name = f"{stem}.pdf"
-                        st.download_button("⬇️ Download PDF", data=pdf_bytes, file_name=pdf_name, mime="application/pdf")
-                    else:
-                        st.error("Failed to generate PDF from markdown.")
-                else:
-                    # Fallback to original simple PDF generation for mixed content
-                    buf = io.BytesIO()
-                    
-                    # Get page dimensions for the selected page size
-                    if page_size == "A4":
-                        page_dimensions = A4
-                    elif page_size == "Letter":
-                        page_dimensions = letter
-                    elif page_size == "Legal":
-                        page_dimensions = legal
-                    elif page_size == "A3":
-                        page_dimensions = A3
-                    elif page_size == "A5":
-                        page_dimensions = A5
-                    else:
-                        page_dimensions = A4
-                    
-                    c = canvas.Canvas(buf, pagesize=page_dimensions)
-                    
-                    if plain_text.strip():
-                        page_w, page_h = page_dimensions
-                        margin = 40
-                        gutter = 20
-                        col_w = (page_w - 2*margin - (columns-1)*gutter) / columns
-                        c.setFont(font_family, font_size)
-                        line_height = font_size * 1.2
-                        col = 0
-                        x = margin
-                        y = page_h - margin
-                        avg_char_width = font_size * 0.6
-                        wrap_width = int(col_w / avg_char_width) if avg_char_width > 0 else 100
-                        for paragraph in plain_text.split("\n"):
-                            if not paragraph.strip():
-                                y -= line_height
-                                if y < margin:
-                                    col += 1
-                                    if col >= columns:
-                                        c.showPage()
-                                        c.setFont(font_family, font_size)
-                                        col = 0
-                                    x = margin + col*(col_w+gutter)
-                                    y = page_h - margin
-                                continue
-                            for line in textwrap.wrap(paragraph, wrap_width):
-                                if y < margin:
-                                    col += 1
-                                    if col >= columns:
-                                        c.showPage()
-                                        c.setFont(font_family, font_size)
-                                        col = 0
-                                    x = margin + col*(col_w+gutter)
-                                    y = page_h - margin
-                                c.drawString(x, y, line)
-                                y -= line_height
-                            y -= line_height
-                    for img_f in ordered_images:
-                        try:
-                            img = Image.open(img_f)
-                            w, h = img.size
-                            c.showPage()
-                            c.setPageSize((w, h))
-                            c.drawImage(ImageReader(img), 0, 0, w, h, preserveAspectRatio=False)
-                        except Exception as e:
-                            st.warning(f"Could not process image {img_f.name}: {e}")
-                            continue
-                    c.save()
-                    buf.seek(0)
-                    pdf_name = f"{stem}.pdf"
-                    st.success(f"PDF generated successfully with {page_size} page size!")
-                    st.download_button("⬇️ Download PDF", data=buf, file_name=pdf_name, mime="application/pdf")
-    
-    st.markdown("---")
-    st.subheader("📂 Available Assets")
-    all_assets = glob.glob("*.*")
-    excluded_extensions = ['.py', '.ttf', '.txt']
-    excluded_files = ['README.md', 'index.html']
-    assets = sorted([
-        a for a in all_assets
-        if not (a.lower().endswith(tuple(excluded_extensions)) or a in excluded_files)
-        and a.lower().endswith(('.md', '.png', '.jpg', '.jpeg'))
-    ])
-    if 'selected_assets' not in st.session_state:
-        st.session_state.selected_assets = []
-    if not assets:
-        st.info("No available assets found.")
+        doc.build(story)
+        
+    except Exception as e:
+        st.error(f"Failed to process {md_path.name} with ReportLab: {e}")
+
+
+# --- Streamlit UI and File Handling (Mostly Unchanged) ---
+
+def get_file_download_link(file_path: Path) -> str:
+    """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():
+    """Renders a simple file explorer in the Streamlit app."""
+    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. Create a `.md` file to begin.")
     else:
-        for a in assets:
-            ext = a.split('.')[-1].lower()
-            cols = st.columns([1, 3, 1, 1])
-            with cols[0]:
-                is_selected = st.checkbox("", key=f"select_{a}", value=a in st.session_state.selected_assets)
-                if is_selected and a not in st.session_state.selected_assets:
-                    st.session_state.selected_assets.append(a)
-                elif not is_selected and a in st.session_state.selected_assets:
-                    st.session_state.selected_assets.remove(a)
-            cols[1].write(a)
-            try:
-                if ext == 'md':
-                    with open(a, 'r', encoding='utf-8') as f:
-                        cols[2].download_button("📥", data=f.read(), file_name=a, mime="text/markdown")
-                elif ext in ['png', 'jpg', 'jpeg']:
-                    with open(a, 'rb') as img_file:
-                        cols[2].download_button("⬇️", data=img_file, file_name=a, mime=f"image/{ext}")
-                cols[3].button("🗑️", key=f"del_{a}", on_click=delete_asset, args=(a,))
-            except Exception as e:
-                cols[3].error(f"Error handling file {a}: {e}")
-        if st.button("📑 Generate PDF from Selected Assets"):
-            if not st.session_state.selected_assets:
-                st.warning("Please select at least one asset to generate a PDF.")
-            else:
-                selected_markdown_texts = []
-                image_files = []
-                for a in st.session_state.selected_assets:
-                    ext = a.split('.')[-1].lower()
-                    if ext == 'md':
-                        with open(a, 'r', encoding='utf-8') as f:
-                            selected_markdown_texts.append(f.read())
-                    elif ext in ['png', 'jpg', 'jpeg']:
-                        image_files.append(a)
-                with st.spinner("Generating PDF from selected assets..."):
-                    pdf_bytes = create_pdf(
-                        markdown_texts=selected_markdown_texts,
-                        image_files=image_files,
-                        base_font_size=font_size,
-                        num_columns=columns,
-                        add_space_before_numbered=True,
-                        headings_to_fonts=True,
-                        doc_title="Combined_Selected_Assets",
-                        page_size=page_size
-                    )
-                    if pdf_bytes:
-                        pdf_images = pdf_to_image(pdf_bytes)
-                        if pdf_images:
-                            st.subheader("Preview of Generated PDF")
-                            for i, img in enumerate(pdf_images):
-                                st.image(img, caption=f"Page {i+1}", use_container_width=True)
-                        prefix = datetime.now().strftime("%Y%m%d_%H%M%S")
-                        st.download_button(
-                            label="💾 Download Combined PDF",
-                            data=pdf_bytes,
-                            file_name=f"{prefix}_combined.pdf",
-                            mime="application/pdf"
-                        )
-                    else:
-                        st.error("Failed to generate PDF.")
-    
-    st.markdown("---")
-    st.subheader("🖼 Image Gallery")
-    image_files = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
-    image_cols = st.slider("Gallery Columns 🖼", min_value=1, max_value=15, value=5, key="image_cols")
-    if image_files:
-        cols = st.columns(image_cols)
-        for idx, image_file in enumerate(image_files):
-            with cols[idx % image_cols]:
-                try:
-                    img = Image.open(image_file)
-                    st.image(img, caption=image_file, use_container_width=True)
-                    display_glossary_entity(os.path.splitext(image_file)[0])
-                except Exception as e:
-                    st.warning(f"Could not load image {image_file}: {e}")
+        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")
+    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.")
     else:
-        st.info("No images found in the current directory.")
+        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 ---
+
+st.set_page_config(layout="wide", page_title="PDF Generator")
+
+st.title("📄 Markdown to PDF Generator (ReportLab Engine)")
+st.markdown("This tool finds all `.md` files in this directory, converts them to PDF in various layouts, and provides download links. It uses the `ReportLab` library and requires no external dependencies.")
+
+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 now creating the PDF.\n\n### Features\n- Item 1\n- Item 2\n\n1. Numbered item\n2. Another one\n\n```\ndef hello():\n    print(\"Hello, PDF!\")\n```\n")
+    st.rerun()
+
+if st.button("🚀 Generate PDFs from all Markdown Files", type="primary"):
+    markdown_files = list(Path(".").glob("*.md"))
     
-    st.markdown("---")
-    st.subheader("🎥 Video Gallery")
-    video_files = glob.glob("*.mp4")
-    video_cols = st.slider("Gallery Columns 🎬", min_value=1, max_value=5, value=3, key="video_cols")
-    if video_files:
-        cols = st.columns(video_cols)
-        for idx, video_file in enumerate(video_files):
-            with cols[idx % video_cols]:
-                st.markdown(get_video_html(video_file, width="100%"), unsafe_allow_html=True)
-                display_glossary_entity(os.path.splitext(video_file)[0])
+    if not markdown_files:
+        st.warning("No `.md` files found. Please add a markdown file to the directory.")
     else:
-        st.info("No videos found in the current directory.")
+        total_pdfs = len(markdown_files) * len(LAYOUTS)
+        progress_bar = st.progress(0)
+        pdf_count = 0
 
-with tab2:
-    st.header("🧪 Python Code Executor & Demo")
-    import io, sys
-    from contextlib import redirect_stdout
-    DEFAULT_CODE = '''import streamlit as st
-import random
-st.title("📊 Demo App")
-st.markdown("Random number and color demo")
-col1, col2 = st.columns(2)
-with col1:
-    num = st.number_input("Number:", 1, 100, 10)
-    mul = st.slider("Multiplier:", 1, 10, 2)
-    if st.button("Calc"):
-        st.write(num * mul)
-with col2:
-    color = st.color_picker("Pick color","#ff0000")
-    st.markdown(f'<div style="background:{color};padding:10px;">Color</div>', unsafe_allow_html=True)
-'''
-    def extract_python_code(md: str) -> list:
-        return re.findall(r"```python\s*(.*?)```", md, re.DOTALL)
-    def execute_code(code: str) -> tuple:
-        buf = io.StringIO(); local_vars = {}
-        try:
-            with redirect_stdout(buf):
-                exec(code, {}, local_vars)
-            return buf.getvalue(), None
-        except Exception as e:
-            return None, str(e)
-    up = st.file_uploader("Upload .py or .md", type=['py', 'md'])
-    if 'code' not in st.session_state:
-        st.session_state.code = DEFAULT_CODE
-    if up:
-        text = up.getvalue().decode()
-        if up.type == 'text/markdown':
-            codes = extract_python_code(text)
-            if codes:
-                st.session_state.code = codes[0].strip()
-            else:
-                st.warning("No Python code block found in the markdown file.")
-                st.session_state.code = ''
-        else:
-            st.session_state.code = text.strip()
-        st.code(st.session_state.code, language='python')
-    else:
-        st.session_state.code = st.text_area("💻 Code Editor", value=st.session_state.code, height=400)
-    c1, c2 = st.columns([1, 1])
-    if c1.button("▶️ Run Code"):
-        if st.session_state.code.strip():
-            out, err = execute_code(st.session_state.code)
-            if err:
-                st.error(f"Execution Error:\n{err}")
-            elif out:
-                st.subheader("Output:")
-                st.code(out)
-            else:
-                st.success("Executed with no standard output.")
-        else:
-            st.warning("No code to run.")
-    if c2.button("🗑️ Clear Code"):
-        st.session_state.code = ''
-        st.rerun()
+        with st.spinner("Generating PDFs using ReportLab..."):
+            for md_file in markdown_files:
+                st.info(f"Processing: **{md_file.name}**")
+                for name, properties in LAYOUTS.items():
+                    st.write(f"   - Generating `{name}` format...")
+                    create_pdf_with_reportlab(md_file, name, properties)
+                    pdf_count += 1
+                    progress_bar.progress(pdf_count / total_pdfs)
+
+        st.success("✅ PDF generation complete!")
+        st.rerun()
+
+display_file_explorer()