Update app.py

app.py

@@ -17,9 +17,13 @@ from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
 from datetime import datetime
 import pytz
+from pypdf import PdfReader, PdfWriter
+from pypdf.annotations import Link
+from reportlab.pdfgen import canvas
 
 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)
@@ -63,10 +67,8 @@ def trim_emojis_except_numbered(markdown_text):
     
     for line in lines:
         if number_pattern.match(line):
-            # Keep emojis in numbered lines
             processed_lines.append(line)
         else:
-            # Remove emojis from other lines
             processed_lines.append(emoji_pattern.sub('', line))
     
     return '\n'.join(processed_lines)
@@ -163,8 +165,6 @@ def markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers,
     pdf_content = []
     number_pattern = re.compile(r'^\d+\.\s')
     heading_pattern = re.compile(r'^(#{1,4})\s+(.+)$')
-    
-    # Track if we've seen the first numbered line already
     first_numbered_seen = False
     
     for line in lines:
@@ -172,34 +172,26 @@ def markdown_to_pdf_content(markdown_text, render_with_bold, auto_bold_numbers,
         if not line:
             continue
             
-        # Process headings if headings_to_fonts is enabled
         if headings_to_fonts and line.startswith('#'):
             heading_match = heading_pattern.match(line)
             if heading_match:
-                level = len(heading_match.group(1))  # Number of # symbols
+                level = len(heading_match.group(1))
                 heading_text = heading_match.group(2).strip()
-                # Convert the heading to bold with appropriate formatting
                 formatted_heading = f"<h{level}>{heading_text}</h{level}>"
                 pdf_content.append(formatted_heading)
                 continue
                 
-        # Check if this is a numbered line
         is_numbered_line = number_pattern.match(line) is not None
         
-        # Add a blank line before numbered lines (except the first one with "1.")
         if add_space_before_numbered and is_numbered_line:
-            # Only add space if this isn't the first numbered line
             if first_numbered_seen and not line.startswith("1."):
-                pdf_content.append("")  # Add an empty line
-            # Mark that we've seen a numbered line
+                pdf_content.append("")
             if not first_numbered_seen:
                 first_numbered_seen = True
         
         line = detect_and_convert_links(line)
         
-        # Process bold text (*word* or **word**)
         if render_with_bold or headings_to_fonts:
-            # Handle both *word* and **word** patterns
             line = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', line)
             if headings_to_fonts:
                 line = re.sub(r'\*([^*]+?)\*', r'<b>\1</b>', line)
@@ -285,25 +277,22 @@ def create_pdf(markdown_text, base_font_size, render_with_bold, auto_bold_number
     for col_idx, column in enumerate(columns):
         for item in column:
             if isinstance(item, str):
-                # Handle heading tags if headings_to_fonts is enabled
                 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)
-                    # Create heading styles based on level
                     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),  # Size decreases with level
+                        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))
-                # Handle regular bold items
                 elif item.startswith("<b>") and item.endswith("</b>"):
                     content = item[3:-4].strip()
                     if number_pattern.match(content):
@@ -349,6 +338,86 @@ def pdf_to_image(pdf_bytes):
         st.error(f"Failed to render PDF preview: {e}")
         return None
 
+# PDF creation and linking function
+WORDS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]
+
+def create_and_link_pdfs(source_pdf="TestSource.pdf", target_pdf="TestTarget.pdf"):
+    """Create two PDFs with numbered lists, add links and bookmarks."""
+    def create_base_pdf(filename):
+        buffer = io.BytesIO()
+        c = canvas.Canvas(buffer)
+        c.setFont("Helvetica", 12)
+        for i, word in enumerate(WORDS, 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)
+        writer.add_bookmark("Seven Bookmark", 0, [50, y_position])
+        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),
+            target=f"{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=0,
+            target_position=[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
+
+# 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]
 
@@ -372,30 +441,24 @@ with st.sidebar:
     add_space_before_numbered = st.checkbox("Add Space Ahead of Numbered Lines", value=False, key="add_space_before_numbered")
     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")
-    
-    # Add AutoColumns option to automatically determine column count based on line length
     auto_columns = st.checkbox("AutoColumns", value=False, key="auto_columns")
     
-    # Auto-determine column count based on longest line if AutoColumns is checked
     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():  # Skip empty lines
+            if line.strip():
                 word_count = len(line.split())
                 longest_line_words = max(longest_line_words, word_count)
-        
-        # Set recommended columns based on word count
         if longest_line_words > 25:
-            recommended_columns = 1  # Very long lines need a single column
+            recommended_columns = 1
         elif longest_line_words >= 18:
-            recommended_columns = 2  # Long lines need 2 columns
+            recommended_columns = 2
         elif longest_line_words >= 11:
-            recommended_columns = 3  # Medium lines can use 3 columns
+            recommended_columns = 3
         else:
-            recommended_columns = "Auto"  # Default to auto for shorter lines
-            
+            recommended_columns = "Auto"
         st.info(f"Longest line has {longest_line_words} words. Recommending {recommended_columns} columns.")
     else:
         recommended_columns = "Auto"
@@ -406,10 +469,8 @@ with st.sidebar:
     num_columns = 0 if num_columns == "Auto" else int(num_columns)
     st.info("Font size and columns adjust to fit one page.")
     
-    # Changed label from "Modify the markdown content below:" to "Input Markdown"
     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}")
     
-    # Added emoji to "Update PDF" button and created a two-column layout for buttons
     col1, col2 = st.columns(2)
     with col1:
         if st.button("🔄📄 Update PDF"):
@@ -419,7 +480,6 @@ with st.sidebar:
                     f.write(edited_markdown)
             st.rerun()
     
-    # Added "Trim Emojis" button in second column
     with col2:
         if st.button("✂️ Trim Emojis"):
             trimmed_content = trim_emojis_except_numbered(edited_markdown)
@@ -452,6 +512,43 @@ with st.sidebar:
             file_name=audio_filename,
             mime="audio/mpeg"
         )
+    
+    # Existing "Create Linked PDFs" button
+    if st.button("📑 Create Linked PDFs"):
+        with st.spinner("Creating and linking PDFs..."):
+            source_pdf, target_pdf = create_and_link_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"
+                    )
+    
+    # New "Test PDFs" button
+    if st.button("🧪 Test PDFs"):
+        with st.spinner("Generating and testing PDFs..."):
+            source_pdf, target_pdf = create_and_link_pdfs()
+            st.success(f"Generated {source_pdf} and {target_pdf}")
+            # Display PDFs as images
+            for pdf_file in [source_pdf, target_pdf]:
+                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 img in images:
+                        st.image(img, caption=f"{pdf_file} Page", use_container_width=True)
+                # Provide download option
+                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)