Delete backup10.app.py

backup10.app.py

@@ -1,635 +0,0 @@
-import io
-import re
-import os
-import glob
-import asyncio
-import hashlib
-import unicodedata
-import streamlit as st
-from PIL import Image
-import fitz
-import edge_tts
-from reportlab.lib.pagesizes import A4
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib import colors
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-from reportlab.pdfgen import canvas
-from datetime import datetime
-import pytz
-from pypdf import PdfReader, PdfWriter
-from pypdf.annotations import Link
-from pypdf.generic import Fit
-
-st.set_page_config(layout="wide", initial_sidebar_state="collapsed")
-
-# Existing functions (unchanged)
-def get_timestamp_prefix():
-    central = pytz.timezone("US/Central")
-    now = datetime.now(central)
-    return now.strftime("%a %m%d %I%M%p").upper()
-
-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)
-    text = emoji_pattern.sub('', text)
-    return text
-
-def trim_emojis_except_numbered(markdown_text):
-    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]+"
-    )
-    number_pattern = re.compile(r'^\d+\.\s')
-    lines = markdown_text.strip().split('\n')
-    processed_lines = []
-    
-    for line in lines:
-        if number_pattern.match(line):
-            processed_lines.append(line)
-        else:
-            processed_lines.append(emoji_pattern.sub('', line))
-    
-    return '\n'.join(processed_lines)
-
-async def generate_audio(text, voice, filename):
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(filename)
-    return filename
-
-def detect_and_convert_links(text):
-    url_pattern = re.compile(
-        r'(https?://|www\.)[^\s\[\]()<>{}]+(\.[^\s\[\]()<>{}]+)+(/[^\s\[\]()<>{}]*)?',
-        re.IGNORECASE
-    )
-    md_link_pattern = re.compile(r'\[(.*?)\]\((https?://[^\s\[\]()<>{}]+)\)')
-    text = md_link_pattern.sub(r'<a href="\2">\1</a>', text)
-    start_idx = 0
-    result = []
-    while start_idx < len(text):
-        match = url_pattern.search(text, start_idx)
-        if not match:
-            result.append(text[start_idx:])
-            break
-        prev_text = text[start_idx:match.start()]
-        tag_balance = prev_text.count('<a') - prev_text.count('</a')
-        if tag_balance > 0:
-            result.append(text[start_idx:match.end()])
-        else:
-            result.append(text[start_idx:match.start()])
-            url = match.group(0)
-            if url.startswith('www.'):
-                url_with_prefix = 'http://' + url
-            else:
-                url_with_prefix = url
-            result.append(f'<a href="{url_with_prefix}">{url}</a>')
-        start_idx = match.end()
-    return ''.join(result)
-
-def apply_emoji_font(text, emoji_font):
-    link_pattern = re.compile(r'<a\s+href="([^"]+)">(.*?)</a>')
-    links = []
-    def save_link(match):
-        link_idx = len(links)
-        links.append((match.group(1), match.group(2)))
-        return f"###LINK_{link_idx}###"
-    text = link_pattern.sub(save_link, text)
-    text = re.sub(r'<b>(.*?)</b>', lambda m: f'###BOLD_START###{m.group(1)}###BOLD_END###', text)
-    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)
-        emoji = unicodedata.normalize('NFC', emoji)
-        return f'<font face="{emoji_font}">{emoji}</font>'
-    segments = []
-    last_pos = 0
-    for match in emoji_pattern.finditer(text):
-        start, end = match.span()
-        if last_pos < start:
-            segments.append(f'<font face="DejaVuSans">{text[last_pos:start]}</font>')
-        segments.append(replace_emoji(match))
-        last_pos = end
-    if last_pos < len(text):
-        segments.append(f'<font face="DejaVuSans">{text[last_pos:]}</font>')
-    combined_text = ''.join(segments)
-    combined_text = combined_text.replace('###BOLD_START###', '</font><b><font face="DejaVuSans">')
-    combined_text = combined_text.replace('###BOLD_END###', '</font></b><font face="DejaVuSans">')
-    for i, (url, label) in enumerate(links):
-        placeholder = f"###LINK_{i}###"
-        if placeholder in combined_text:
-            parts = combined_text.split(placeholder)
-            if len(parts) == 2:
-                before, after = parts
-                if before.rfind('<font') > before.rfind('</font>'):
-                    link_html = f'</font><a href="{url}">{label}</a><font face="DejaVuSans">'
-                    combined_text = before + link_html + after
-                else:
-                    combined_text = before + f'<a href="{url}">{label}</a>' + after
-    return combined_text
-
-def markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers, add_space_before_numbered, headings_to_fonts):
-    lines = markdown_text.strip().split('\n')
-    pdf_content = []
-    number_pattern = re.compile(r'^\d+\.\s')
-    heading_pattern = re.compile(r'^(#{1,4})\s+(.+)$')
-    first_numbered_seen = False
-    
-    for line in lines:
-        line = line.strip()
-        if not line:
-            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)
-        
-        if render_with_bold or headings_to_fonts:
-            line = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', line)
-            if headings_to_fonts:
-                line = re.sub(r'\*([^*]+?)\*', r'<b>\1</b>', line)
-                
-        if auto_bold_numbers and is_numbered_line:
-            if not (line.startswith("<b>") and line.endswith("</b>")):
-                if "<b>" in line and "</b>" in line:
-                    line = re.sub(r'</?b>', '', line)
-                    line = f"<b>{line}</b>"
-                else:
-                    line = f"<b>{line}</b>"
-        pdf_content.append(line)
-    total_lines = len(pdf_content)
-    return pdf_content, total_lines
-
-def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_numbers, enlarge_numbered, num_columns, add_space_before_numbered, headings_to_fonts):
-    buffer = io.BytesIO()
-    page_width = A4[0] * 2
-    page_height = A4[1]
-    doc = SimpleDocTemplate(buffer, pagesize=(page_width, page_height), leftMargin=36, rightMargin=36, topMargin=36, bottomMargin=36)
-    styles = getSampleStyleSheet()
-    spacer_height = 10
-    pdf_content, total_lines = markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers, add_space_before_numbered, headings_to_fonts)
-    try:
-        available_font_files = glob.glob("*.ttf")
-        if not available_font_files:
-            st.error("No .ttf font files found.")
-            return
-        selected_font_path = next((f for f in available_font_files if "NotoEmoji-Bold" in f), None)
-        if selected_font_path:
-            pdfmetrics.registerFont(TTFont("NotoEmoji-Bold", selected_font_path))
-        pdfmetrics.registerFont(TTFont("DejaVuSans", "DejaVuSans.ttf"))
-    except Exception as e:
-        st.error(f"Font registration error: {e}")
-        return
-    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)
-    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
-    ideal_lines_per_col = 20
-    suggested_columns = max(1, min(6, int(total_lines / ideal_lines_per_col) + 1))
-    num_columns = num_columns if num_columns != 0 else suggested_columns
-    col_width = usable_width / num_columns
-    min_font_size = 6
-    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)
-    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 + 1 if enlarge_numbered else adjusted_font_size,
-        leading=(adjusted_font_size + 1) * 1.15 if enlarge_numbered else 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+\.\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, "DejaVuSans"), item_style))
-            else:
-                column_cells[col_idx].append(Paragraph(apply_emoji_font(str(item), "DejaVuSans"), 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 = [Spacer(1, spacer_height), table]
-    doc.build(story)
-    buffer.seek(0)
-    return buffer.getvalue()
-
-def pdf_to_image(pdf_bytes):
-    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
-
-# PDF creation and linking functions
-WORDS_10 = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]
-WORDS_20 = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
-            "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty"]
-
-def create_crossfile_pdfs(source_pdf="TestSource.pdf", target_pdf="TestTarget.pdf"):
-    """Create two PDFs with cross-file linking."""
-    def create_base_pdf(filename):
-        buffer = io.BytesIO()
-        c = canvas.Canvas(buffer)
-        c.setFont("Helvetica", 12)
-        for i, word in enumerate(WORDS_10, 1):
-            y = 800 - (i * 20)
-            c.drawString(50, y, f"{i}. {word}")
-        c.showPage()
-        c.save()
-        buffer.seek(0)
-        with open(filename, "wb") as f:
-            f.write(buffer.getvalue())
-        buffer.close()
-
-    def add_bookmark_to_seven(pdf_file):
-        reader = PdfReader(pdf_file)
-        writer = PdfWriter()
-        for page in reader.pages:
-            writer.add_page(page)
-        page = writer.pages[0]
-        y_position = 800 - (7 * 20)
-        fit = Fit(fit_type="/XYZ", fit_args=[50, y_position, 0])
-        writer.add_outline_item("Seven Bookmark", 0, fit=fit)
-        with open(pdf_file, "wb") as f:
-            writer.write(f)
-
-    def modify_source_pdf(source, target):
-        reader = PdfReader(source)
-        writer = PdfWriter()
-        for page in reader.pages:
-            writer.add_page(page)
-        buffer = io.BytesIO()
-        c = canvas.Canvas(buffer)
-        c.setFont("Helvetica", 8)
-        seven_y = 800 - (7 * 20)
-        c.drawString(90, seven_y - 5, "link")
-        c.showPage()
-        c.save()
-        buffer.seek(0)
-        text_pdf = PdfReader(buffer)
-        page = writer.pages[0]
-        page.merge_page(text_pdf.pages[0])
-        link = Link(
-            rect=(90, seven_y - 10, 150, seven_y + 10),
-            url=f"file://{os.path.abspath(target)}#page=1"
-        )
-        writer.add_annotation(page_number=0, annotation=link)
-        with open(source, "wb") as f:
-            writer.write(f)
-        buffer.close()
-
-    def add_internal_link(pdf_file):
-        reader = PdfReader(pdf_file)
-        writer = PdfWriter()
-        for page in reader.pages:
-            writer.add_page(page)
-        one_y = 800 - (1 * 20)
-        ten_y = 800 - (10 * 20)
-        link = Link(
-            rect=(50, one_y - 10, 100, one_y + 10),
-            target_page_index=0,
-            fit=Fit(fit_type="/XYZ", fit_args=[50, ten_y, 0])
-        )
-        writer.add_annotation(page_number=0, annotation=link)
-        with open(pdf_file, "wb") as f:
-            writer.write(f)
-
-    create_base_pdf(source_pdf)
-    create_base_pdf(target_pdf)
-    add_bookmark_to_seven(target_pdf)
-    modify_source_pdf(source_pdf, target_pdf)
-    add_internal_link(source_pdf)
-    add_internal_link(target_pdf)
-    return source_pdf, target_pdf
-
-def create_selflinking_pdf(pdf_file="SelfLinking.pdf"):
-    """Create a PDF with a TOC on page 1 linking to a 1-20 list starting on page 2."""
-    buffer = io.BytesIO()
-    c = canvas.Canvas(buffer)
-    
-    # Page 1: Table of Contents
-    c.setFont("Helvetica", 14)
-    c.drawString(50, 800, "Table of Contents")
-    c.setFont("Helvetica", 12)
-    toc_y_positions = []
-    for i, word in enumerate(WORDS_10, 1):
-        y = 760 - (i * 20)
-        c.drawString(50, y, f"{word}")
-        toc_y_positions.append(y)
-    c.showPage()
-    
-    # Page 2: Numbered list 1-20
-    c.setFont("Helvetica", 12)
-    list_y_positions = []
-    for i, word in enumerate(WORDS_20, 1):
-        y = 800 - (i * 20)
-        c.drawString(50, y, f"{i}. {word}")
-        list_y_positions.append(y)
-    c.showPage()
-    
-    # Save the initial PDF
-    c.save()
-    buffer.seek(0)
-    with open(pdf_file, "wb") as f:
-        f.write(buffer.getvalue())
-    buffer.close()
-
-    # Add outlines and links
-    reader = PdfReader(pdf_file)
-    writer = PdfWriter()
-    for page in reader.pages:
-        writer.add_page(page)
-
-    # Add outline entries
-    toc_page = writer.pages[0]
-    list_page = writer.pages[1]
-    writer.add_outline_item("Table of Contents", 0, fit=Fit(fit_type="/Fit"))
-    for i, word in enumerate(WORDS_10, 1):
-        y = list_y_positions[i-1]
-        writer.add_outline_item(word, 1, fit=Fit(fit_type="/XYZ", fit_args=[50, y, 0]))
-
-    # Add TOC links from page 1 to page 2
-    for i, word in enumerate(WORDS_10):
-        toc_y = toc_y_positions[i]
-        list_y = list_y_positions[i]
-        link = Link(
-            rect=(50, toc_y - 10, 150, toc_y + 10),
-            target_page_index=1,
-            fit=Fit(fit_type="/XYZ", fit_args=[50, list_y, 0])
-        )
-        writer.add_annotation(page_number=0, annotation=link)
-
-    # Save the modified PDF
-    with open(pdf_file, "wb") as f:
-        writer.write(f)
-
-    return pdf_file
-
-# Streamlit UI
-md_files = [f for f in glob.glob("*.md") if os.path.basename(f) != "README.md"]
-md_options = [os.path.splitext(os.path.basename(f))[0] for f in md_files]
-
-with st.sidebar:
-    st.markdown("### PDF Options")
-    if md_options:
-        selected_md = st.selectbox("Select Markdown File", options=md_options, index=0)
-        with open(f"{selected_md}.md", "r", encoding="utf-8") as f:
-            st.session_state.markdown_content = f.read()
-    else:
-        st.warning("No markdown file found. Please add one to your folder.")
-        selected_md = None
-        st.session_state.markdown_content = ""
-    available_font_files = {os.path.splitext(os.path.basename(f))[0]: f for f in glob.glob("*.ttf")}
-    selected_font_name = st.selectbox("Select Emoji Font", options=list(available_font_files.keys()), 
-                                      index=list(available_font_files.keys()).index("NotoEmoji-Bold") if "NotoEmoji-Bold" in available_font_files else 0)
-    base_font_size = st.slider("Font Size (points)", min_value=6, max_value=16, value=8, step=1)
-    render_with_bold = st.checkbox("Render with Bold Formatting (remove ** markers)", value=True, key="render_with_bold")
-    auto_bold_numbers = st.checkbox("Auto Bold Numbered Lines", value=True, key="auto_bold_numbers")
-    enlarge_numbered = st.checkbox("Enlarge Font Size for Numbered Lines", value=True, key="enlarge_numbered")
-    add_space_before_numbered = st.checkbox("Add Space Ahead of Numbered Lines", value=False, key="add_space_before_numbered")
-
-    # Here we use a font that has more emojis
-    headings_to_fonts = st.checkbox("Headings to Fonts", value=False, key="headings_to_fonts", 
-                               help="Convert Markdown headings (# Heading) and emphasis (*word*) to appropriate font styles")
-    
-    auto_columns = st.checkbox("AutoColumns", value=False, key="auto_columns")
-    
-    if auto_columns and 'markdown_content' in st.session_state:
-        current_markdown = st.session_state.markdown_content
-        lines = current_markdown.strip().split('\n')
-        longest_line_words = 0
-        for line in lines:
-            if line.strip():
-                word_count = len(line.split())
-                longest_line_words = max(longest_line_words, word_count)
-        if longest_line_words > 25:
-            recommended_columns = 1
-        elif longest_line_words >= 18:
-            recommended_columns = 2
-        elif longest_line_words >= 11:
-            recommended_columns = 3
-        else:
-            recommended_columns = "Auto"
-        st.info(f"Longest line has {longest_line_words} words. Recommending {recommended_columns} columns.")
-    else:
-        recommended_columns = "Auto"
-    
-    column_options = ["Auto"] + list(range(1, 7))
-    num_columns = st.selectbox("Number of Columns", options=column_options, 
-                              index=0 if recommended_columns == "Auto" else column_options.index(recommended_columns))
-    num_columns = 0 if num_columns == "Auto" else int(num_columns)
-    st.info("Font size and columns adjust to fit one page.")
-    
-    edited_markdown = st.text_area("Input Markdown", value=st.session_state.markdown_content, height=300, key=f"markdown_{selected_md}_{selected_font_name}_{num_columns}")
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        if st.button("🔄📄 Update PDF"):
-            st.session_state.markdown_content = edited_markdown
-            if selected_md:
-                with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
-                    f.write(edited_markdown)
-            st.rerun()
-    
-    with col2:
-        if st.button("✂️ Trim Emojis"):
-            trimmed_content = trim_emojis_except_numbered(edited_markdown)
-            st.session_state.markdown_content = trimmed_content
-            if selected_md:
-                with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
-                    f.write(trimmed_content)
-            st.rerun()
-    
-    prefix = get_timestamp_prefix()
-    st.download_button(
-        label="💾📝 Save Markdown",
-        data=st.session_state.markdown_content,
-        file_name=f"{prefix} {selected_md}.md" if selected_md else f"{prefix} default.md",
-        mime="text/markdown"
-    )
-    st.markdown("### Text-to-Speech")
-    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 Audio"):
-        cleaned_text = clean_for_speech(st.session_state.markdown_content)
-        audio_filename = f"{prefix} {selected_md} {selected_voice}.mp3" if selected_md else f"{prefix} default {selected_voice}.mp3"
-        audio_file = asyncio.run(generate_audio(cleaned_text, selected_voice, audio_filename))
-        st.audio(audio_file)
-        with open(audio_file, "rb") as f:
-            audio_bytes = f.read()
-        st.download_button(
-            label="💾🔊 Save Audio",
-            data=audio_bytes,
-            file_name=audio_filename,
-            mime="audio/mpeg"
-        )
-    
-    if st.button("📑 Create CrossFile PDFs"):
-        with st.spinner("Creating cross-file linked PDFs..."):
-            source_pdf, target_pdf = create_crossfile_pdfs()
-            st.success(f"Created {source_pdf} and {target_pdf}")
-            for pdf_file in [source_pdf, target_pdf]:
-                with open(pdf_file, "rb") as f:
-                    st.download_button(
-                        label=f"💾 Download {pdf_file}",
-                        data=f.read(),
-                        file_name=pdf_file,
-                        mime="application/pdf"
-                    )
-    
-    if st.button("🧪 Create SelfLinking PDF"):
-        with st.spinner("Generating self-linking PDF with TOC..."):
-            pdf_file = create_selflinking_pdf()
-            st.success(f"Generated {pdf_file}")
-            with open(pdf_file, "rb") as f:
-                pdf_bytes = f.read()
-            images = pdf_to_image(pdf_bytes)
-            if images:
-                st.subheader(f"Preview of {pdf_file}")
-                for i, img in enumerate(images):
-                    st.image(img, caption=f"{pdf_file} Page {i+1}", use_container_width=True)
-            with open(pdf_file, "rb") as f:
-                st.download_button(
-                    label=f"💾 Download {pdf_file}",
-                    data=f.read(),
-                    file_name=pdf_file,
-                    mime="application/pdf"
-                )
-
-with st.spinner("Generating PDF..."):
-    pdf_bytes = create_pdf(st.session_state.markdown_content, base_font_size, render_with_bold, auto_bold_numbers, enlarge_numbered, num_columns, add_space_before_numbered, headings_to_fonts)
-
-with st.container():
-    pdf_images = pdf_to_image(pdf_bytes)
-    if pdf_images:
-        for img in pdf_images:
-            st.image(img, use_container_width=True)
-    else:
-        st.info("Download the PDF to view it locally.")
-
-with st.sidebar:
-    st.download_button(
-        label="💾📄 Save PDF",
-        data=pdf_bytes,
-        file_name=f"{prefix} {selected_md}.pdf" if selected_md else f"{prefix} output.pdf",
-        mime="application/pdf"
-    )