Update app.py

app.py

@@ -20,20 +20,13 @@ import pytz
 
 st.set_page_config(layout="wide", initial_sidebar_state="collapsed")
 
-# 🕒 Time flies when you're having function calls
 def get_timestamp_prefix():
-    """🕰️ Gets a timestamp that's more reliable than your coworker's ETA estimates"""
     central = pytz.timezone("US/Central")
     now = datetime.now(central)
-    # Format: three-letter day, MMDD, HHMM + AM/PM (all uppercase)
     return now.strftime("%a %m%d %I%M%p").upper()
 
-# 🧹 Because text needs a bath before being spoken
 def clean_for_speech(text):
-    """🧼 Scrubs your text cleaner than your bathroom will ever be"""
-    # Remove hash marks
     text = text.replace("#", "")
-    # Remove emojis using a regex pattern that covers a wide range
     emoji_pattern = re.compile(
         r"[\U0001F300-\U0001F5FF"
         r"\U0001F600-\U0001F64F"
@@ -49,86 +42,49 @@ def clean_for_speech(text):
     text = emoji_pattern.sub('', text)
     return text
 
-# 🎤 Making robots talk so you don't have to
 async def generate_audio(text, voice, filename):
-    """🔊 Turn text into speech, because reading is so last century"""
     communicate = edge_tts.Communicate(text, voice)
     await communicate.save(filename)
     return filename
 
-# 🔗 Detecting links like a digital bloodhound
 def detect_and_convert_links(text):
-    """🕸️ Finds URLs in your text and turns them into actual clickable links"""
-    # Pattern to find URLs (http/https/ftp/www)
     url_pattern = re.compile(
         r'(https?://|www\.)[^\s\[\]()<>{}]+(\.[^\s\[\]()<>{}]+)+(/[^\s\[\]()<>{}]*)?',
         re.IGNORECASE
     )
-    
-    # Pattern to find markdown links [text](url)
     md_link_pattern = re.compile(r'\[(.*?)\]\((https?://[^\s\[\]()<>{}]+)\)')
-    
-    # First convert markdown links
     text = md_link_pattern.sub(r'<a href="\2">\1</a>', text)
-    
-    # Then find and convert plain URLs not already in tags
     start_idx = 0
     result = []
-    
     while start_idx < len(text):
-        # Find the next URL
         match = url_pattern.search(text, start_idx)
         if not match:
-            # No more URLs, add the remaining text
             result.append(text[start_idx:])
             break
-        
-        # Check if the URL is already inside an <a> tag
-        # This is a simplified check. A more robust approach might use an HTML parser
         prev_text = text[start_idx:match.start()]
         tag_balance = prev_text.count('<a') - prev_text.count('</a')
-        
         if tag_balance > 0:
-            # URL is likely inside a tag, skip this match
             result.append(text[start_idx:match.end()])
         else:
-            # Add text before the URL
             result.append(text[start_idx:match.start()])
-            
-            # Get the URL
             url = match.group(0)
-            
-            # Add proper URL prefix if needed
             if url.startswith('www.'):
                 url_with_prefix = 'http://' + url
             else:
                 url_with_prefix = url
-            
-            # Add the URL as a link
             result.append(f'<a href="{url_with_prefix}">{url}</a>')
-        
         start_idx = match.end()
-    
     return ''.join(result)
 
-# 🎭 Making emojis wear the right font costume
 def apply_emoji_font(text, emoji_font):
-    """🦄 Because emojis deserve their own font fashion show"""
-    # First handle links - temporarily replace them with placeholders
     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)
-    
-    # Now handle bold formatting
     text = re.sub(r'<b>(.*?)</b>', lambda m: f'###BOLD_START###{m.group(1)}###BOLD_END###', text)
-    
-    # Apply emoji font replacement
     emoji_pattern = re.compile(
         r"([\U0001F300-\U0001F5FF"
         r"\U0001F600-\U0001F64F"
@@ -137,95 +93,65 @@ def apply_emoji_font(text, emoji_font):
         r"\U0001F780-\U0001F7FF"
         r"\U0001F800-\U0001F8FF"
         r"\U0001F900-\U0001F9FF"
-        r"\U0001FAD0-\U0001FAD9"  # additional range if needed
+        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)
-    
-    # Restore bold tags
     combined_text = combined_text.replace('###BOLD_START###', '</font><b><font face="DejaVuSans">')
     combined_text = combined_text.replace('###BOLD_END###', '</font></b><font face="DejaVuSans">')
-    
-    # Restore links
     for i, (url, label) in enumerate(links):
         placeholder = f"###LINK_{i}###"
         if placeholder in combined_text:
-            # If the link is within a font tag, we need to close and reopen it
             parts = combined_text.split(placeholder)
             if len(parts) == 2:
                 before, after = parts
-                # Check if we're inside a font tag
                 if before.rfind('<font') > before.rfind('</font>'):
-                    # Close font tag before link, reopen after
                     link_html = f'</font><a href="{url}">{label}</a><font face="DejaVuSans">'
                     combined_text = before + link_html + after
                 else:
-                    # Simple replacement
                     combined_text = before + f'<a href="{url}">{label}</a>' + after
-    
     return combined_text
 
-# 📝 Converting markdown to PDF content, because PDFs never go out of style
 def markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers):
-    """📋 Transforms your disorganized thoughts into structured PDF content"""
     lines = markdown_text.strip().split('\n')
     pdf_content = []
     number_pattern = re.compile(r'^\d+\.\s')
-    
     for line in lines:
         line = line.strip()
         if not line or line.startswith('# '):
             continue
-        
-        # Process links before any other formatting
         line = detect_and_convert_links(line)
-            
-        # Handle bold formatting
         if render_with_bold:
             line = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', line)
-            
         if auto_bold_numbers and number_pattern.match(line):
-            # Only apply bold if not already entirely bold
             if not (line.startswith("<b>") and line.endswith("</b>")):
-                # If there's already some bold formatting inside, we need to handle carefully
                 if "<b>" in line and "</b>" in line:
-                    # Complex case - for simplicity, just make the whole line bold
-                    # but remove any existing bold tags first
                     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
 
-# 🏗️ Building PDFs like it's your second job
 def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_numbers, enlarge_numbered, num_columns):
-    """🔨 Constructs a PDF with the precision of a sleep-deprived architect"""
     buffer = io.BytesIO()
     page_width = A4[0] * 2
     page_height = A4[1]
@@ -233,58 +159,64 @@ def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_number
     styles = getSampleStyleSheet()
     spacer_height = 10
     pdf_content, total_lines = markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers)
-    
-    # Define styles for different text types
-    item_style = ParagraphStyle(
-        'ItemStyle', parent=styles['Normal'], fontName="DejaVuSans",
-        fontSize=base_font_size, leading=base_font_size * 1.15, spaceAfter=1,
-        linkUnderline=True  # Enable underline for links
-    )
-    numbered_bold_style = ParagraphStyle(
-        'NumberedBoldStyle', parent=styles['Normal'], fontName="NotoEmoji-Bold",
-        fontSize=base_font_size + 1 if enlarge_numbered else base_font_size,
-        leading=(base_font_size + 1) * 1.15 if enlarge_numbered else base_font_size * 1.15, spaceAfter=1,
-        linkUnderline=True  # Enable underline for links
-    )
-    section_style = ParagraphStyle(
-        'SectionStyle', parent=styles['Heading2'], fontName="DejaVuSans",
-        textColor=colors.darkblue, fontSize=base_font_size * 1.1, leading=base_font_size * 1.32, spaceAfter=2,
-        linkUnderline=True  # Enable underline for links
-    )
-    
-    # Register fonts
     try:
         available_font_files = glob.glob("*.ttf")
         if not available_font_files:
-            st.error("No .ttf font files found in the current directory.")
+            st.error("No .ttf font files found.")
             return
-        selected_font_path = None
-        for f in available_font_files:
-            if "NotoEmoji-Bold" in f:
-                selected_font_path = f
-                break
+        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
-        
-    # Distribute content across columns
+    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
-        
-    # Format columns into Paragraph objects
     column_cells = [[] for _ in range(num_columns)]
     for col_idx, column in enumerate(columns):
         for item in column:
@@ -296,14 +228,9 @@ def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_number
                     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))
-                
-    # Ensure columns have the same number of cells
     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)))
-        
-    # Create the table layout
-    col_width = (page_width - 72) / num_columns if num_columns > 0 else page_width - 72
     table_data = list(zip(*column_cells)) if column_cells else [[]]
     table = Table(table_data, colWidths=[col_width] * num_columns, hAlign='CENTER')
     table.setStyle(TableStyle([
@@ -317,16 +244,12 @@ def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_number
         ('TOPPADDING', (0, 0), (-1, -1), 1),
         ('BOTTOMPADDING', (0, 0), (-1, -1), 1),
     ]))
-    
-    # Build the PDF
     story = [Spacer(1, spacer_height), table]
     doc.build(story)
     buffer.seek(0)
     return buffer.getvalue()
 
-# 🖼️ Converting PDFs to images, because we can't leave well enough alone
 def pdf_to_image(pdf_bytes):
-    """🔎 Turns your PDF into pictures because some people just want to see the world rendered"""
     try:
         doc = fitz.open(stream=pdf_bytes, filetype="pdf")
         images = []
@@ -340,11 +263,9 @@ def pdf_to_image(pdf_bytes):
         st.error(f"Failed to render PDF preview: {e}")
         return None
 
-# -- Markdown File Selection --
 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]
 
-# 🎪 The main Streamlit show begins here
 with st.sidebar:
     st.markdown("### PDF Options")
     if md_options:
@@ -355,7 +276,6 @@ with st.sidebar:
         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)
@@ -363,9 +283,10 @@ with st.sidebar:
     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")
-    num_columns = st.selectbox("Number of Columns", options=[1, 2, 3, 4, 5, 6], index=3)
-
-    # Use the file's content for editing
+    column_options = ["Auto"] + list(range(1, 7))
+    num_columns = st.selectbox("Number of Columns", options=column_options, index=0)
+    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("Modify the markdown content below:", value=st.session_state.markdown_content, height=300, key=f"markdown_{selected_md}_{selected_font_name}_{num_columns}")
     if st.button("Update PDF"):
         st.session_state.markdown_content = edited_markdown
@@ -373,25 +294,18 @@ with st.sidebar:
             with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
                 f.write(edited_markdown)
         st.rerun()
-
-    # Create a timestamp prefix for file naming
     prefix = get_timestamp_prefix()
-
-    # Download button for Markdown with new naming convention and double emoji label
     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"):
-        # Clean markdown input for speech generation
         cleaned_text = clean_for_speech(st.session_state.markdown_content)
-        # Create a filename for the audio file using the timestamp, markdown name, and selected voice
         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)
@@ -404,11 +318,9 @@ with st.sidebar:
             mime="audio/mpeg"
         )
 
-# 🚀 Generating the PDF with more complexity than a rocket launch
 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)
 
-# 📺 Displaying the preview, because everyone loves to window shop
 with st.container():
     pdf_images = pdf_to_image(pdf_bytes)
     if pdf_images:
@@ -417,7 +329,6 @@ with st.container():
     else:
         st.info("Download the PDF to view it locally.")
 
-# 💾 Last chance to save your masterpiece before it's gone forever
 with st.sidebar:
     st.download_button(
         label="💾📄 Save PDF",