Update app.py

app.py

@@ -9,7 +9,7 @@ import streamlit as st
 import pandas as pd
 from PIL import Image
 from reportlab.pdfgen import canvas
-from reportlab.lib.pagesizes import letter, A4
+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
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
@@ -130,12 +130,28 @@ def markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_t
     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"):
+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()
-    page_width = A4[0] * 2
-    page_height = A4[1]
+    
+    # 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),
@@ -255,8 +271,8 @@ def create_pdf(markdown_texts, image_files, base_font_size=14, num_columns=2, ad
         try:
             img = Image.open(img_path)
             img_width, img_height = img.size
-            page_width, page_height = A4
-            scale = min((page_width - 40) / img_width, (page_height - 40) / img_height)
+            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))
@@ -312,36 +328,94 @@ 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, 2)
-    font_family = st.sidebar.selectbox("Font", ["Helvetica", "Times-Roman", "Courier", "DejaVuSans"])
-    font_size = st.sidebar.slider("Font size", 6, 24, 14)
-    # Markdown input
-    md_file = st.file_uploader("Upload Markdown (.md)", type=["md"])
-    if md_file:
-        md_text = md_file.getvalue().decode("utf-8")
-        stem = Path(md_file.name).stem
+    
+    # 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)
+        
+        # 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
+        )
+        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:
-        md_text = st.text_area("Or enter markdown text directly", height=200)
+        # 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
-    renderer = mistune.HTMLRenderer()
-    markdown = mistune.create_markdown(renderer=renderer)
-    html = markdown(md_text or "")
-    plain_text = re.sub(r'<[^>]+>', '', html)
+    
+    # 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)
+        
+        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
-    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")
-    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)
+    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:
-                cleaned_text = clean_for_speech(plain_text)
-                audio_file = asyncio.run(generate_audio(cleaned_text, selected_voice, voice_file))
+                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")
@@ -349,10 +423,13 @@ with tab1:
                 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():
@@ -360,62 +437,111 @@ with tab1:
                 if f.name == row['name']:
                     ordered_images.append(f)
                     break
-    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.")
+    
+    # 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:
-            buf = io.BytesIO()
-            c = canvas.Canvas(buf)
-            if plain_text.strip():
-                page_w, page_h = letter
-                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.download_button("⬇️ Download PDF", data=buf, file_name=pdf_name, mime="application/pdf")
+            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("*.*")
@@ -455,24 +581,25 @@ with tab1:
             if not st.session_state.selected_assets:
                 st.warning("Please select at least one asset to generate a PDF.")
             else:
-                markdown_texts = []
+                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:
-                            markdown_texts.append(f.read())
+                            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=markdown_texts,
+                        markdown_texts=selected_markdown_texts,
                         image_files=image_files,
-                        base_font_size=14,
-                        num_columns=2,
+                        base_font_size=font_size,
+                        num_columns=columns,
                         add_space_before_numbered=True,
                         headings_to_fonts=True,
-                        doc_title="Combined_Selected_Assets"
+                        doc_title="Combined_Selected_Assets",
+                        page_size=page_size
                     )
                     if pdf_bytes:
                         pdf_images = pdf_to_image(pdf_bytes)
@@ -489,6 +616,7 @@ with tab1:
                         )
                     else:
                         st.error("Failed to generate PDF.")
+    
     st.markdown("---")
     st.subheader("🖼 Image Gallery")
     image_files = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
@@ -505,6 +633,7 @@ with tab1:
                     st.warning(f"Could not load image {image_file}: {e}")
     else:
         st.info("No images found in the current directory.")
+    
     st.markdown("---")
     st.subheader("🎥 Video Gallery")
     video_files = glob.glob("*.mp4")