Update app.py

app.py

@@ -10,7 +10,7 @@ import streamlit as st
 import pandas as pd
 from PIL import Image
 from reportlab.pdfgen import canvas
-from reportlab.lib.pagesizes import letter
+from reportlab.lib.pagesizes import letter # Using letter size for consistency
 from reportlab.lib.utils import ImageReader
 import mistune
 from gtts import gTTS
@@ -19,50 +19,224 @@ from gtts import gTTS
 st.set_page_config(page_title="PDF & Code Interpreter", layout="wide", page_icon="🚀")
 
 def delete_asset(path):
+    """Deletes a file asset and reruns the app."""
     try:
         os.remove(path)
+        # Also remove from session state selection if it exists
+        if 'selected_assets' in st.session_state and path in st.session_state.selected_assets:
+            del st.session_state.selected_assets[path]
     except Exception as e:
         st.error(f"Error deleting file: {e}")
     st.rerun()
 
+# --- New Function to Generate Combined PDF ---
+def generate_combined_pdf(selected_asset_paths):
+    """Generates a single PDF from selected markdown and image file paths."""
+    buf = io.BytesIO()
+    c = canvas.Canvas(buf)
+
+    # --- Process Markdown Files ---
+    all_plain_text = ""
+    md_count = 0
+    for path in selected_asset_paths:
+        # Process only markdown files first
+        if path.lower().endswith('.md'):
+            md_count += 1
+            try:
+                with open(path, 'r', encoding='utf-8') as f:
+                    md_text = f.read()
+                # Convert Markdown to plain text using mistune (removes formatting but keeps content)
+                renderer = mistune.HTMLRenderer()
+                markdown = mistune.create_markdown(renderer=renderer)
+                html = markdown(md_text or "")
+                plain_text = re.sub(r'<[^>]+>', '', html) # Strip HTML tags
+
+                if all_plain_text:
+                    all_plain_text += "\n\n---\n\n" # Add a separator between combined MD files
+                all_plain_text += plain_text
+
+            except Exception as e:
+                st.warning(f"Could not read or process markdown file {path}: {e}")
+                # Decide if you want to continue or stop if an MD fails
+
+    # Render combined markdown content if any was found
+    if all_plain_text.strip():
+        # --- Canvas Text Rendering (2 columns, 14pt font) ---
+        page_w, page_h = letter # Use standard letter size (8.5 x 11 inches, approx 612 x 792 points)
+        margin = 40 # Margin around the content area (points)
+        gutter = 15 # Space between columns (points)
+        num_columns = 2 # Fixed number of columns as requested
+
+        # Calculate available width for text and column width
+        available_text_width = page_w - 2 * margin
+        col_w = (available_text_width - (num_columns - 1) * gutter) / num_columns
+
+        font_family = "Helvetica" # A standard font available in ReportLab canvas
+        font_size = 14 # Font size as requested
+        c.setFont(font_family, font_size)
+
+        # Estimate line height and character width for text wrapping
+        # ReportLab units are points. Approximating char width for wrapping.
+        # A common approximation for average character width is font_size * 0.6
+        avg_char_width_points = font_size * 0.6
+        # wrap_width is the number of characters that fit in one line of a column
+        wrap_width = int(col_w / avg_char_width_points) if avg_char_width_points > 0 else 100 # Prevent division by zero
+
+        line_height = font_size * 1.3 # Line spacing (e.g., 1.3 times font size)
+
+        # Initialize column and vertical position
+        col = 0
+        x = margin + col * (col_w + gutter) # Starting x for the first column
+        y = page_h - margin # Starting y from the top margin
+
+        paragraphs = all_plain_text.split("\n")
+
+        for paragraph in paragraphs:
+            # Handle empty lines (add vertical space)
+            if not paragraph.strip():
+                y -= line_height / 2 # Add less space for blank lines compared to paragraphs
+                # Check for page/column break after adding vertical space
+                if y < margin:
+                    col += 1
+                    if col >= num_columns:
+                        c.showPage() # Move to a new page
+                        c.setFont(font_family, font_size) # Re-set font after new page
+                        col = 0 # Reset to the first column
+                        x = margin + col * (col_w + gutter) # Reset x position
+                        y = page_h - margin # Reset y position to top margin
+                    else:
+                         # Move to the next column on the same page
+                        x = margin + col * (col_w + gutter)
+                        y = page_h - margin # Reset y position to top margin
+                continue # Move to the next paragraph
+
+            # Wrap the paragraph text into lines that fit the column width
+            lines = textwrap.wrap(paragraph, wrap_width)
+
+            for line in lines:
+                # Check for page/column break before drawing the line
+                if y < margin:
+                    col += 1
+                    if col >= num_columns:
+                        c.showPage() # Move to a new page
+                        c.setFont(font_family, font_size) # Re-set font after new page
+                        col = 0 # Reset to the first column
+                        x = margin + col * (col_w + gutter) # Reset x position
+                        y = page_h - margin # Reset y position to top margin
+                    else:
+                        # Move to the next column on the same page
+                        x = margin + col * (col_w + gutter)
+                        y = page_h - margin # Reset y position to top margin
+
+                # Draw the line
+                c.drawString(x, y, line)
+                # Move y position down for the next line
+                y -= line_height
+
+            # Add extra space after a paragraph (except the last one)
+            if paragraph != paragraphs[-1] or lines: # Add space if it's not the very last line of the last paragraph
+                 y -= line_height / 2
+
+        # After all markdown text, ensure subsequent images start on a new page
+        if all_plain_text.strip():
+             c.showPage() # Start images on a fresh page
+
+    # --- Process Image Files ---
+    image_count = 0
+    for path in selected_asset_paths:
+        # Process image files after markdown
+        if path.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')): # Add other image types if needed
+            image_count += 1
+            try:
+                img = Image.open(path)
+                img_w, img_h = img.size
+
+                # Get current page size (should be letter if no text was added or after showPage)
+                page_w, page_h = letter
+                margin_img = 40 # Margin around the image on the page
+
+                # Calculate available space within margins on the page
+                available_w = page_w - 2 * margin_img
+                available_h = page_h - 2 * margin_img
+
+                # Calculate scaling factor to fit the image within the available space while preserving aspect ratio
+                scale = min(available_w / img_w, available_h / img_h)
+                draw_w = img_w * scale
+                draw_h = img_h * scale
+
+                # Calculate position to center the scaled image on the page
+                pos_x = margin_img + (available_w - draw_w) / 2
+                # Position from the bottom left corner
+                pos_y = margin_img + (available_h - draw_h) / 2
+
+                # Draw the image. Ensure it's on a new page.
+                # If this is the first image and no text was added, it will use the initial page.
+                # Otherwise, showPage() is called before drawing.
+                if image_count > 1 or all_plain_text.strip():
+                    c.showPage() # Start a new page for this image
+
+                # Draw the image onto the current page
+                c.drawImage(path, pos_x, pos_y, width=draw_w, height=draw_h, preserveAspectRatio=True)
+
+            except Exception as e:
+                st.warning(f"Could not process image file {path}: {e}")
+                continue # Continue with other selected assets
+
+    # If no markdown or images were selected/processed
+    if not all_plain_text.strip() and image_count == 0:
+        page_w, page_h = letter
+        c.drawString(40, page_h - 40, "No selected markdown or image files to generate PDF.")
+
+    c.save() # Finalize the PDF
+    buf.seek(0) # Rewind the buffer to the beginning
+    return buf.getvalue() # Return the PDF bytes
+# --- End of New Function ---
+
+
 # Tabs setup
 tab1, tab2 = st.tabs(["📄 PDF Composer", "🧪 Code Interpreter"])
 
 with tab1:
     st.header("📄 PDF Composer & Voice Generator 🚀")
 
-    # Sidebar PDF text settings
-    columns = st.sidebar.slider("Text columns", 1, 3, 1)
-    font_family = st.sidebar.selectbox("Font", ["Helvetica","Times-Roman","Courier"])
-    font_size = st.sidebar.slider("Font size", 6, 24, 12)
-
-    # Markdown input
-    md_file = st.file_uploader("Upload Markdown (.md)", type=["md"])
+    # Sidebar settings for the original PDF composer
+    # These settings (columns, font size for the *first* PDF button) are separate
+    # from the settings for the combined PDF generation below.
+    st.sidebar.markdown("### Original PDF Composer Settings")
+    columns = st.sidebar.slider("Text columns (Original PDF)", 1, 3, 1)
+    font_family = st.sidebar.selectbox("Font (Original PDF)", ["Helvetica","Times-Roman","Courier"])
+    font_size = st.sidebar.slider("Font size (Original PDF)", 6, 24, 12)
+
+    # Markdown input for the original PDF composer
+    st.markdown("#### Original PDF Composer Input")
+    md_file = st.file_uploader("Upload Markdown (.md) for Original PDF", type=["md"])
     if md_file:
         md_text = md_file.getvalue().decode("utf-8")
-        stem = Path(md_file.name).stem
+        # Use stem from uploaded file or timestamp if text area is used
+        original_pdf_stem = Path(md_file.name).stem
     else:
-        md_text = st.text_area("Or enter markdown text directly", height=200)
-        stem = datetime.now().strftime('%Y%m%d_%H%M%S')
+        md_text = st.text_area("Or enter markdown text directly for Original PDF", height=200)
+        original_pdf_stem = datetime.now().strftime('%Y%m%d_%H%M%S')
 
-    # Convert Markdown to plain text
-    # Using mistune to parse markdown to HTML, then stripping HTML tags
+    # Convert Markdown to plain text for original PDF
     renderer = mistune.HTMLRenderer()
     markdown = mistune.create_markdown(renderer=renderer)
     html = markdown(md_text or "")
-    plain_text = re.sub(r'<[^>]+>', '', html) # Strip HTML tags
+    original_pdf_plain_text = re.sub(r'<[^>]+>', '', html) # Strip HTML tags
 
-    # Voice settings
+    # Voice settings (Applies to the text entered above)
+    st.markdown("#### Voice Generation from Text Input")
     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")
 
     if st.button("🔊 Generate & Download Voice MP3 from Text"):
-        if plain_text.strip():
-            voice_file = f"{stem}.mp3"
+        if original_pdf_plain_text.strip():
+            voice_file = f"{original_pdf_stem}.mp3"
             try:
-                tts = gTTS(text=plain_text, lang=voice_lang, slow=slow)
+                # Using the plain text from the text area/uploaded MD for voice
+                tts = gTTS(text=original_pdf_plain_text, lang=voice_lang, slow=slow)
                 tts.save(voice_file)
                 st.audio(voice_file)
                 with open(voice_file, 'rb') as mp3:
@@ -72,29 +246,33 @@ with tab1:
         else:
             st.warning("No text to generate voice from.")
 
-    # Image uploads and ordering
-    imgs = st.file_uploader("Upload Images for PDF", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
-    ordered_images = []
+    # Image uploads and ordering for the original PDF composer
+    st.markdown("#### Images for Original PDF")
+    imgs = st.file_uploader("Upload Images for Original PDF", type=["png", "jpg", "jpeg"], accept_multiple_files=True)
+    ordered_images_original_pdf = []
     if imgs:
         # Create a DataFrame for editing image order
         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") # Use num_rows="dynamic" for better UI
-        # Reconstruct the ordered list of file objects
+        # Use num_rows="dynamic" for better UI, though less relevant if not adding/deleting rows
+        edited = st.data_editor(df_imgs, use_container_width=True)
+        # Reconstruct the ordered list of file objects based on edited order
         for _, row in edited.sort_values("order").iterrows():
             for f in imgs:
                 if f.name == row['name']:
-                    ordered_images.append(f)
+                    ordered_images_original_pdf.append(f)
                     break # Found the file object, move to the next row
 
-    if st.button("🖋️ Generate PDF with Markdown & Images"):
-        if not plain_text.strip() and not ordered_images:
-             st.warning("Please provide some text or upload images to generate a PDF.")
+
+    # --- Original PDF Generation Button ---
+    if st.button("🖋️ Generate Original PDF with Markdown & Images"):
+        if not original_pdf_plain_text.strip() and not ordered_images_original_pdf:
+             st.warning("Please provide some text or upload images to generate the Original PDF.")
         else:
             buf = io.BytesIO()
             c = canvas.Canvas(buf)
 
-            # Render text with columns if there is text
-            if plain_text.strip():
+            # Render text using original settings and logic if text is provided
+            if original_pdf_plain_text.strip():
                 page_w, page_h = letter
                 margin = 40
                 gutter = 20
@@ -104,101 +282,205 @@ with tab1:
                 col = 0
                 x = margin
                 y = page_h - margin
-                # Estimate wrap width based on font size and column width
-                # This is an approximation and might need fine-tuning
-                avg_char_width = font_size * 0.6 # Approximation
-                wrap_width = int(col_w / avg_char_width) if avg_char_width > 0 else 100 # Prevent division by zero
-
-                for paragraph in plain_text.split("\n"):
-                    # Handle empty lines by adding vertical space
-                    if not paragraph.strip():
-                        y -= line_height
-                        if y < margin:
+                # Estimate wrap width
+                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 original_pdf_plain_text.split("\n"):
+                    if not paragraph.strip(): # Handle empty lines
+                         y -= line_height / 2
+                         if y < margin: # Check for column/page break
+                              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
+                              else:
+                                   x = margin + col*(col_w+gutter)
+                                   y = page_h - margin
+                         continue
+
+                    lines = textwrap.wrap(paragraph, wrap_width) if paragraph.strip() else [""]
+
+                    for line in lines:
+                        if y < margin: # Check for column/page break
                             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 # Skip to next paragraph
+                                x = margin + col*(col_w+gutter)
+                                y = page_h - margin
+                            else:
+                                x = margin + col*(col_w+gutter)
+                                y = page_h - margin
 
-                    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 # Add space between paragraphs
 
-            # Autosize pages to each image
-            for img_f in ordered_images:
+                    y -= line_height / 2 # Space after paragraph
+
+                # Ensure images start on a new page if text was added
+                if original_pdf_plain_text.strip():
+                     c.showPage()
+
+            # Autosize pages to each uploaded image
+            image_count = 0
+            for img_f in ordered_images_original_pdf:
+                image_count += 1
                 try:
-                    img = Image.open(img_f)
+                    img = Image.open(img_f) # img_f is a file-like object from st.file_uploader
                     w, h = img.size
-                    c.showPage() # Start a new page for each image
-                    # Set page size to image size
-                    c.setPageSize((w, h))
-                    # Draw image filling the page
-                    c.drawImage(ImageReader(img), 0, 0, w, h, preserveAspectRatio=False) # Use False to fill page exactly
+
+                    # Start a new page for each image
+                    if image_count > 1 or original_pdf_plain_text.strip():
+                         c.showPage()
+
+                    # Draw image scaled to fit a letter page within margins, centered
+                    page_w, page_h = letter
+                    margin_img = 40
+                    available_w = page_w - 2 * margin_img
+                    available_h = page_h - 2 * margin_img
+
+                    scale = min(available_w / w, available_h / h)
+                    draw_w = w * scale
+                    draw_h = h * scale
+
+                    pos_x = margin_img + (available_w - draw_w) / 2
+                    pos_y = margin_img + (available_h - draw_h) / 2
+
+                    # Use ImageReader for file-like objects
+                    c.drawImage(ImageReader(img_f), pos_x, pos_y, width=draw_w, height=draw_h, preserveAspectRatio=True)
+
                 except Exception as e:
-                    st.warning(f"Could not process image {img_f.name}: {e}")
+                    st.warning(f"Could not process uploaded image {img_f.name}: {e}")
                     continue
 
+            # If nothing was generated
+            if not original_pdf_plain_text.strip() and not ordered_images_original_pdf:
+                 page_w, page_h = letter
+                 c.drawString(40, page_h - 40, "No content to generate Original PDF.")
+
+
             c.save()
             buf.seek(0)
-            pdf_name = f"{stem}.pdf"
-            st.download_button("⬇️ Download PDF", data=buf, file_name=pdf_name, mime="application/pdf")
+            pdf_name = f"{original_pdf_stem}.pdf"
+            st.download_button("⬇️ Download Original PDF", data=buf, file_name=pdf_name, mime="application/pdf")
 
     st.markdown("---")
     st.subheader("📂 Available Assets")
+    st.markdown("Select assets below and click 'Generate Combined PDF'.")
+
     # Get all files and filter out unwanted ones
     all_assets = glob.glob("*.*")
     excluded_extensions = ['.py', '.ttf']
-    excluded_files = ['README.md', 'index.html']
+    excluded_files = ['README.md', 'index.html'] # Added index.html here
 
     assets = sorted([
         a for a in all_assets
-        if not (a.lower().endswith(tuple(excluded_extensions)) or a in excluded_files)
+        if not (a.lower().endswith(tuple(excluded_extensions)) or os.path.basename(a) in excluded_files)
     ])
 
+    # Initialize session state for selected assets if not already done
+    if 'selected_assets' not in st.session_state:
+        st.session_state.selected_assets = {}
+
+    # Ensure all current assets have an entry in session state, initialize to False if new
+    # Clean up session state from assets that no longer exist
+    current_asset_paths = [os.path.abspath(a) for a in assets]
+    st.session_state.selected_assets = {
+        k: v for k, v in st.session_state.selected_assets.items()
+        if os.path.abspath(k) in current_asset_paths # Keep only existing assets
+    }
+    for asset_path in assets:
+         if asset_path not in st.session_state.selected_assets:
+              st.session_state.selected_assets[asset_path] = False
+
+
+    # --- Display Assets with Checkboxes ---
     if not assets:
         st.info("No available assets found.")
     else:
+        # Header row for clarity
+        header_cols = st.columns([0.5, 3, 1, 1])
+        header_cols[1].write("**File**")
+        # header_cols[2].write("**Action**") # Optional header
+
+
         for a in assets:
             ext = a.split('.')[-1].lower()
-            cols = st.columns([3, 1, 1])
-            cols[0].write(a)
+            cols = st.columns([0.5, 3, 1, 1])
+
+            # Checkbox in the first column, updating session state
+            # Use absolute path for robust keying in case of directory changes (less likely in Streamlit sharing, but good practice)
+            asset_key = os.path.abspath(a)
+            st.session_state.selected_assets[a] = cols[0].checkbox("", value=st.session_state.selected_assets.get(a, False), key=f"select_asset_{asset_key}")
 
-            # Provide download/preview based on file type
+            # File name in the second column
+            cols[1].write(a)
+
+            # Provide download/preview based on file type in the third column
             try:
                 if ext == 'pdf':
                     with open(a, 'rb') as fp:
-                        cols[1].download_button("📥", data=fp, file_name=a, mime="application/pdf")
+                        cols[2].download_button("📥", data=fp, file_name=a, mime="application/pdf", key=f"download_{a}")
                 elif ext == 'mp3':
-                    # Streamlit can play audio directly from file path
-                    cols[1].audio(a)
+                    # Audio player takes up too much space here, just offer download
                     with open(a, 'rb') as mp3:
-                         cols[1].download_button("📥", data=mp3, file_name=a, mime="audio/mpeg")
+                         cols[2].download_button("📥", data=mp3, file_name=a, mime="audio/mpeg", key=f"download_{a}")
                 # Add more file types here if needed (e.g., images)
                 elif ext in ['png', 'jpg', 'jpeg', 'gif']:
                      # Can't preview image directly in this column, offer download
                      with open(a, 'rb') as img_file:
-                         cols[1].download_button("⬇️", data=img_file, file_name=a, mime=f"image/{ext}")
+                         cols[2].download_button("⬇️", data=img_file.read(), file_name=a, mime=f"image/{ext}", key=f"download_{a}")
+                elif ext == 'md':
+                    # Offer download for markdown files
+                    with open(a, 'r', encoding='utf-8') as md_file:
+                        cols[2].download_button("⬇️", data=md_file.read(), file_name=a, mime="text/markdown", key=f"download_{a}")
                 # Handle other file types - maybe just offer download
                 else:
                      with open(a, 'rb') as other_file:
-                         cols[1].download_button("⬇️", data=other_file, file_name=a) # Mime type is guessed by streamlit
+                         cols[2].download_button("⬇️", data=other_file.read(), file_name=a, key=f"download_{a}") # Mime type is guessed by streamlit
 
-                # Delete button
-                cols[2].button("🗑️", key=f"del_{a}", on_click=delete_asset, args=(a,))
+                # Delete button in the fourth column
+                cols[3].button("🗑️", key=f"del_{a}", on_click=delete_asset, args=(a,))
             except Exception as e:
-                cols[2].error(f"Error handling file {a}: {e}")
+                cols[3].error(f"Error handling file {a}: {e}") # Place error in the delete column or add a separate status
+
+
+    # --- Combined PDF Generation Button ---
+    # Only show button if there are any assets listed
+    if assets:
+        if st.button("Generate Combined PDF from Selected Assets"):
+            # Get the list of selected asset paths
+            selected_asset_paths = [path for path, selected in st.session_state.selected_assets.items() if selected]
+
+            if not selected_asset_paths:
+                st.warning("Please select at least one asset.")
+            else:
+                with st.spinner("Generating combined PDF..."):
+                    try:
+                        # Call the new function to generate the combined PDF
+                        combined_pdf_bytes = generate_combined_pdf(selected_asset_paths)
+
+                        if combined_pdf_bytes: # Check if the function returned bytes (meaning content was added)
+                            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                            pdf_name = f"Combined_Assets_{timestamp}.pdf"
+                            # Provide the generated PDF for download
+                            st.download_button(
+                                "⬇️ Download Combined PDF",
+                                data=combined_pdf_bytes,
+                                file_name=pdf_name,
+                                mime="application/pdf"
+                            )
+                            st.success("Combined PDF generated!")
+                        else:
+                            st.warning("Generated PDF is empty. No valid markdown or image files were selected.")
+
+                    except Exception as e:
+                        st.error(f"An unexpected error occurred during PDF generation: {e}")
 
 
 with tab2: