breaks away from single file

app.py

@@ -1,167 +1,111 @@
+# app.py
+"""
+Main Streamlit application file for the PDF to Single Image Converter.
+
+Coordinates the UI, file handling, and calls the processing logic.
+"""
+
 import streamlit as st
-import fitz  # PyMuPDF
-import numpy as np
-from PIL import Image
-import io
 import tempfile
 import os
 import time
+from typing import Optional
 
+# Import functions from our modules
+from pdf_processor import pdf_to_single_image
+from ui_components import (
+    render_sidebar,
+    display_file_details,
+    display_results,
+    render_initial_info,
+    display_installation_info
+)
+
+# --- Page Configuration ---
 st.set_page_config(
     page_title="PDF to Single Image Converter",
     page_icon="📄",
-    layout="centered"
+    layout="centered",  # Can be "wide" or "centered"
+    initial_sidebar_state="expanded" # Keep sidebar open initially
 )
 
+# --- Main Application ---
 st.title("📄 PDF to Single Image Converter")
-st.write("Upload a PDF and convert it into a single image containing all pages.")
-
-def pdf_to_single_image(pdf_path, output_format="PNG", dpi=300):
-    """Convert all pages of a PDF to a single image file"""
-    # Open the PDF
-    pdf_document = fitz.open(pdf_path)
-    num_pages = len(pdf_document)
-    
-    # Calculate total height and get width
-    total_height = 0
-    width = 0
-    
-    # First pass to calculate dimensions
-    zooms = []
-    for page_num in range(num_pages):
-        page = pdf_document[page_num]
-        zoom = dpi / 72  # 72 is the default DPI for PDFs
-        zooms.append(zoom)
-        rect = page.rect
-        width = max(width, int(rect.width * zoom))
-        total_height += int(rect.height * zoom)
-    
-    # Create a new image with the calculated dimensions
-    result_image = Image.new("RGB", (width, total_height), (255, 255, 255))
-    
-    # Second pass to render pages
-    current_height = 0
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    for page_num in range(num_pages):
-        status_text.text(f"Processing page {page_num + 1}/{num_pages}")
-        page = pdf_document[page_num]
-        zoom = zooms[page_num]
-        
-        # Get the page as a pixmap
-        pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom))
-        
-        # Convert pixmap to PIL Image
-        page_image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-        
-        # Paste this page into the result image
-        result_image.paste(page_image, (0, current_height))
-        current_height += pix.height
-        
-        # Update progress
-        progress_bar.progress((page_num + 1) / num_pages)
-    
-    # Create a byte buffer for the image
-    buf = io.BytesIO()
-    if output_format.upper() == "PNG":
-        result_image.save(buf, format="PNG")
-    else:
-        result_image.save(buf, format="JPEG", quality=95)
-    
-    buf.seek(0)
-    pdf_document.close()
-    status_text.text("Processing complete!")
-    return buf
-
-# UI Components
-with st.sidebar:
-    st.header("Settings")
-    dpi = st.slider("Resolution (DPI)", min_value=72, max_value=600, value=300, step=1,
-                   help="Higher DPI means better quality but larger file size")
-    output_format = st.radio("Output Format", ["PNG", "JPG"], 
-                            help="PNG provides better quality but larger file size")
-    st.write("---")
-    st.write("### About")
-    st.write("This app converts multi-page PDFs into a single image file.")
-    st.write("Made with ❤️ using Streamlit and PyMuPDF")
-
-# File uploader
-uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
+st.markdown("Upload a multi-page PDF and convert it into a single, tall image file (PNG or JPG).")
+
+# --- Sidebar ---
+dpi_setting, format_setting = render_sidebar()
 
+# --- File Upload ---
+# Use a key for the file uploader to potentially reset it later if needed
+uploaded_file: Optional[st.runtime.uploaded_file_manager.UploadedFile] = st.file_uploader(
+    "Choose a PDF file", type="pdf", key="pdf_uploader"
+)
+
+# --- Processing Logic ---
 if uploaded_file is not None:
-    # Display file info
-    file_details = {
-        "Filename": uploaded_file.name,
-        "File size": f"{uploaded_file.size / 1024:.2f} KB"
-    }
-    st.write("### File Details")
-    for k, v in file_details.items():
-        st.write(f"**{k}:** {v}")
-    
-    # Save uploaded file to temp file
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
-        tmp_file.write(uploaded_file.getvalue())
-        pdf_path = tmp_file.name
-    
-    # Process on button click
-    if st.button("Convert to Image"):
-        try:
-            with st.spinner("Converting PDF to image..."):
-                start_time = time.time()
-                
-                # Process the PDF
-                img_buffer = pdf_to_single_image(pdf_path, output_format, dpi)
-                
-                # Calculate processing time
-                processing_time = time.time() - start_time
-                st.success(f"Conversion completed in {processing_time:.2f} seconds!")
-                
-                # Get file extension
-                ext = "png" if output_format == "PNG" else "jpg"
-                
-                # Create download button
-                output_filename = f"{os.path.splitext(uploaded_file.name)[0]}.{ext}"
-                st.download_button(
-                    label=f"Download {output_format} Image",
-                    data=img_buffer,
-                    file_name=output_filename,
-                    mime=f"image/{ext.lower()}"
-                )
-                
-                # Preview (with warning for large files)
-                img = Image.open(img_buffer)
-                width, height = img.size
-                aspect_ratio = width / height
-                
-                st.write("### Image Preview")
-                if height > 10000:
-                    st.warning("This is a very tall image. Preview is scaled down.")
-                    st.image(img, caption=f"Output Image ({width}x{height} pixels)", width=min(width, 800))
-                else:
-                    st.image(img, caption=f"Output Image ({width}x{height} pixels)")
-                
-                st.write(f"**Image dimensions:** {width}x{height} pixels")
-        
-        except Exception as e:
-            st.error(f"An error occurred: {e}")
-        
-        finally:
-            # Clean up temp file
-            if os.path.exists(pdf_path):
-                os.unlink(pdf_path)
+    # Display details of the uploaded file
+    display_file_details(uploaded_file)
+
+    # Use a temporary file for robust handling by PyMuPDF
+    temp_pdf_path: Optional[str] = None
+    try:
+        # Create a temporary file to store the uploaded PDF content
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
+            tmp_file.write(uploaded_file.getvalue())
+            temp_pdf_path = tmp_file.name # Store the path
+
+        # Add a button to trigger the conversion
+        if st.button(f"🚀 Convert to {format_setting}", key="convert_button"):
+            if temp_pdf_path: # Ensure temp path is valid
+                try:
+                    # Show a spinner during processing
+                    with st.spinner(f"Converting PDF to {format_setting} at {dpi_setting} DPI... Please wait."):
+                        start_time = time.time()
+
+                        # Call the core conversion function from pdf_processor
+                        img_buffer = pdf_to_single_image(
+                            pdf_path=temp_pdf_path,
+                            output_format=format_setting,
+                            dpi=dpi_setting
+                        )
+
+                        processing_time = time.time() - start_time
+
+                        # Prepare output filename
+                        base_filename = os.path.splitext(uploaded_file.name)[0]
+                        output_filename = f"{base_filename}_converted.{format_setting.lower()}"
+
+                        # Display the results (download button, preview)
+                        if img_buffer.getbuffer().nbytes > 0: # Check if buffer has content
+                             display_results(
+                                img_buffer=img_buffer,
+                                output_filename=output_filename,
+                                output_format=format_setting,
+                                processing_time=processing_time
+                             )
+                        else:
+                             st.error("Conversion resulted in an empty image. Please check the PDF file.")
+
+
+                except Exception as e:
+                    st.error(f"❌ An error occurred during conversion:")
+                    st.exception(e) # Displays the full traceback for debugging
+
+    finally:
+        # --- Cleanup ---
+        # Ensure the temporary file is deleted after processing or if an error occurs
+        if temp_pdf_path and os.path.exists(temp_pdf_path):
+            try:
+                os.unlink(temp_pdf_path)
+                # st.write(f"Temporary file {temp_pdf_path} deleted.") # Optional debug message
+            except OSError as e:
+                st.warning(f"Could not delete temporary file {temp_pdf_path}: {e}")
+
+
 else:
-    st.info("👆 Please upload a PDF file to get started.")
-    
-    # Example image
-    st.write("### Example Output")
-    st.image("https://via.placeholder.com/800x600?text=PDF+to+Single+Image+Example", 
-             caption="Example of converted PDF")
-
-# Add requirements info at the bottom
-st.write("---")
-with st.expander("Installation Requirements"):
-    st.code("""
-    pip install streamlit PyMuPDF Pillow
-    """)
-    st.write("Run the app with: `streamlit run app.py`")
+    # Show initial instructions if no file is uploaded
+    render_initial_info()
+
+# --- Footer / Installation Info ---
+display_installation_info()

pdf_processor.py

@@ -0,0 +1,204 @@
+# pdf_processor.py
+"""
+Handles the core logic of converting a PDF document into a single image.
+"""
+
+import fitz  # PyMuPDF
+from PIL import Image
+import io
+import streamlit as st  # Imported for progress bar updates
+from typing import Tuple, List, Union
+
+# Constants
+DEFAULT_PDF_DPI = 72  # Standard PDF DPI used for scaling calculations
+JPEG_QUALITY = 95     # Quality setting for JPEG output
+
+def calculate_image_dimensions(pdf_document: fitz.Document, dpi: int) -> Tuple[int, int, List[float]]:
+    """
+    Calculates the total dimensions required for the final image canvas.
+
+    Iterates through PDF pages to determine the maximum width and total height
+    needed when rendered at the specified DPI.
+
+    Parameters
+    ----------
+    pdf_document : fitz.Document
+        The opened PyMuPDF document object.
+    dpi : int
+        The target resolution in dots per inch.
+
+    Returns
+    -------
+    Tuple[int, int, List[float]]
+        A tuple containing:
+        - max_width (int): The maximum width required among all pages.
+        - total_height (int): The sum of heights of all pages.
+        - zooms (List[float]): A list of zoom factors for each page.
+    """
+    total_height = 0
+    max_width = 0
+    zooms = []
+    num_pages = len(pdf_document)
+
+    # First pass: Calculate dimensions and zoom factors
+    for page_num in range(num_pages):
+        page = pdf_document[page_num]
+        # Calculate the zoom factor needed to achieve the target DPI
+        zoom = dpi / DEFAULT_PDF_DPI
+        zooms.append(zoom)
+        # Get page dimensions in pixels at the calculated zoom
+        rect = page.rect
+        page_width = int(rect.width * zoom)
+        page_height = int(rect.height * zoom)
+        # Update maximum width and total height
+        max_width = max(max_width, page_width)
+        total_height += page_height
+
+    return max_width, total_height, zooms
+
+def render_pages_to_image(
+    pdf_document: fitz.Document,
+    zooms: List[float],
+    canvas_width: int,
+    canvas_height: int
+) -> Image.Image:
+    """
+    Renders each page of the PDF onto a single PIL Image canvas.
+
+    Parameters
+    ----------
+    pdf_document : fitz.Document
+        The opened PyMuPDF document object.
+    zooms : List[float]
+        A list of zoom factors, one for each page.
+    canvas_width : int
+        The width of the final image canvas.
+    canvas_height : int
+        The height of the final image canvas.
+
+    Returns
+    -------
+    Image.Image
+        A PIL Image object containing all rendered PDF pages.
+    """
+    num_pages = len(pdf_document)
+    # Create a new blank image canvas (RGB white background)
+    result_image = Image.new("RGB", (canvas_width, canvas_height), (255, 255, 255))
+    current_height = 0
+
+    # Initialize Streamlit progress reporting
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+
+    # Second pass: Render each page and paste it onto the canvas
+    for page_num in range(num_pages):
+        status_text.text(f"Processing page {page_num + 1}/{num_pages}...")
+        page = pdf_document[page_num]
+        zoom = zooms[page_num]
+
+        # Generate a pixmap (raster image) of the page
+        # Use fitz.Matrix for transformation with the calculated zoom
+        pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom))
+
+        # Convert the pixmap to a PIL Image
+        # Ensure the mode ("RGB" or "RGBA") matches pix.samples structure if issues arise
+        try:
+            page_image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+        except ValueError as e:
+            st.error(f"Error converting page {page_num+1} to Image: {e}")
+            st.warning(f"Pixmap details: width={pix.width}, height={pix.height}, alpha={pix.alpha}, samples length={len(pix.samples)}")
+            # Attempt RGBA conversion as a fallback if alpha channel is present
+            if pix.alpha:
+                 page_image = Image.frombytes("RGBA", [pix.width, pix.height], pix.samples).convert("RGB")
+                 st.info("Retrying page conversion with RGBA mode.")
+            else:
+                 raise # Re-raise the original error if not an alpha channel issue
+
+        # Paste the page image onto the main canvas
+        # The paste position is (0, current_height)
+        result_image.paste(page_image, (0, current_height))
+        current_height += pix.height # Move down for the next page
+
+        # Update Streamlit progress bar
+        progress_bar.progress((page_num + 1) / num_pages)
+
+    status_text.text("Rendering complete!")
+    return result_image
+
+def pdf_to_single_image(pdf_path: str, output_format: str = "PNG", dpi: int = 300) -> io.BytesIO:
+    """
+    Converts all pages of a PDF file into a single vertical image.
+
+    Opens the PDF, calculates the required dimensions, renders each page
+    at the specified DPI, stitches them together vertically, and returns
+    the result as an image in a BytesIO buffer.
+
+    Parameters
+    ----------
+    pdf_path : str
+        The file path to the input PDF document.
+    output_format : str, optional
+        The desired output image format ("PNG" or "JPG"), by default "PNG".
+    dpi : int, optional
+        The resolution (dots per inch) for rendering the PDF pages, by default 300.
+        Higher DPI results in better quality but larger file size.
+
+    Returns
+    -------
+    io.BytesIO
+        A BytesIO buffer containing the generated image data in the specified format.
+
+    Raises
+    ------
+    fitz.FitzError
+        If there is an error opening or processing the PDF file.
+    Exception
+        For other potential errors during image processing or saving.
+    """
+    pdf_document = None  # Initialize to ensure it's defined in finally block
+    try:
+        # Open the PDF document
+        pdf_document = fitz.open(pdf_path)
+
+        # Calculate the necessary dimensions for the final image
+        canvas_width, canvas_height, zooms = calculate_image_dimensions(pdf_document, dpi)
+
+        if canvas_width == 0 or canvas_height == 0:
+            st.warning("Could not determine valid dimensions for the PDF. It might be empty or corrupted.")
+            return io.BytesIO() # Return empty buffer
+
+        # Render pages onto the canvas
+        result_image = render_pages_to_image(pdf_document, zooms, canvas_width, canvas_height)
+
+        # Create an in-memory buffer to save the image
+        img_buffer = io.BytesIO()
+
+        # Save the final image to the buffer in the specified format
+        if output_format.upper() == "PNG":
+            result_image.save(img_buffer, format="PNG")
+        elif output_format.upper() == "JPG" or output_format.upper() == "JPEG":
+            # Save as JPEG with specified quality, converting RGBA to RGB if necessary
+            if result_image.mode == 'RGBA':
+                 result_image = result_image.convert('RGB')
+            result_image.save(img_buffer, format="JPEG", quality=JPEG_QUALITY)
+        else:
+            # Default to PNG if format is unknown
+            st.warning(f"Unsupported format '{output_format}'. Defaulting to PNG.")
+            result_image.save(img_buffer, format="PNG")
+
+        # Reset buffer position to the beginning for reading
+        img_buffer.seek(0)
+
+        return img_buffer
+
+    except fitz.FitzError as e:
+        st.error(f"Error processing PDF: {e}")
+        raise  # Re-raise the specific exception
+    except Exception as e:
+        st.error(f"An unexpected error occurred during conversion: {e}")
+        raise # Re-raise general exceptions
+    finally:
+        # Ensure the PDF document is closed even if errors occur
+        if pdf_document:
+            pdf_document.close()
+            # st.write("PDF document closed.") # Optional debug message

ui_components.py

@@ -0,0 +1,166 @@
+# ui_components.py
+"""
+Defines functions for creating distinct UI sections of the Streamlit application.
+"""
+
+import streamlit as st
+from typing import Tuple, Dict, Any, Optional
+from PIL import Image
+import io
+
+# Constants
+MAX_PREVIEW_HEIGHT = 10000 # Maximum height in pixels for full-size preview
+
+def render_sidebar() -> Tuple[int, str]:
+    """
+    Renders the sidebar UI elements for settings.
+
+    Returns
+    -------
+    Tuple[int, str]
+        A tuple containing:
+        - dpi (int): The selected resolution in DPI.
+        - output_format (str): The selected output format ('PNG' or 'JPG').
+    """
+    with st.sidebar:
+        st.header("⚙️ Settings")
+        # DPI Slider
+        dpi = st.slider(
+            "Resolution (DPI)",
+            min_value=72,
+            max_value=600,
+            value=300,
+            step=1,
+            help="Dots Per Inch. Higher DPI means better quality but larger file size and longer processing time."
+        )
+        # Output Format Radio Buttons
+        output_format = st.radio(
+            "Output Format",
+            ["PNG", "JPG"],
+            index=0, # Default to PNG
+            help="PNG offers lossless quality (larger file). JPG uses lossy compression (smaller file)."
+        )
+
+        st.write("---")
+        st.write("### About")
+        st.info(
+            "This app converts multi-page PDFs into a single, vertically stitched image file. "
+            "Useful for sharing or archiving documents as images."
+        )
+        st.write("Made with ❤️ using [Streamlit](https://streamlit.io) & [PyMuPDF](https://pymupdf.readthedocs.io/en/latest/)")
+        st.write("Tim might be a 🧙")
+        # A little fun :)
+        # st.write("Tim might be a 🧙") # Uncomment if desired
+
+    return dpi, output_format
+
+def display_file_details(uploaded_file: st.runtime.uploaded_file_manager.UploadedFile) -> None:
+    """
+    Displays details of the uploaded file.
+
+    Parameters
+    ----------
+    uploaded_file : st.runtime.uploaded_file_manager.UploadedFile
+        The file uploaded by the user via st.file_uploader.
+    """
+    file_details = {
+        "Filename": uploaded_file.name,
+        "Type": uploaded_file.type,
+        "Size": f"{uploaded_file.size / (1024*1024):.2f} MB" # Show size in MB
+    }
+    st.write("### File Details")
+    # Use columns for better layout
+    col1, col2 = st.columns(2)
+    with col1:
+        st.write(f"**Filename:**")
+        st.write(f"**Type:**")
+        st.write(f"**Size:**")
+    with col2:
+        st.write(f"{file_details['Filename']}")
+        st.write(f"{file_details['Type']}")
+        st.write(f"{file_details['Size']}")
+
+
+def display_results(
+    img_buffer: io.BytesIO,
+    output_filename: str,
+    output_format: str,
+    processing_time: float
+) -> None:
+    """
+    Displays the conversion results: success message, download button, and image preview.
+
+    Parameters
+    ----------
+    img_buffer : io.BytesIO
+        The buffer containing the generated image data.
+    output_filename : str
+        The suggested filename for the downloaded image.
+    output_format : str
+        The format of the output image ('PNG' or 'JPG').
+    processing_time : float
+        The time taken for the conversion process in seconds.
+    """
+    st.success(f"✅ Conversion completed in {processing_time:.2f} seconds!")
+
+    # Determine MIME type based on format
+    mime_type = f"image/{output_format.lower()}"
+
+    # Provide download button
+    st.download_button(
+        label=f"⬇️ Download {output_format} Image",
+        data=img_buffer,
+        file_name=output_filename,
+        mime=mime_type
+    )
+
+    # Image preview section
+    st.write("---")
+    st.write("### 🖼️ Image Preview")
+    try:
+        # Open image from buffer for preview
+        img = Image.open(img_buffer)
+        width, height = img.size
+        st.write(f"**Image dimensions:** {width}x{height} pixels")
+
+        # Warn and scale down preview if the image is excessively tall
+        if height > MAX_PREVIEW_HEIGHT:
+            st.warning(f"⚠️ Image is very tall ({height}px). Preview is scaled down.")
+            # Calculate width based on a max preview width (e.g., 800px) to maintain aspect ratio
+            preview_width = min(width, 800)
+            st.image(img, caption=f"Scaled Preview of {output_filename}", width=preview_width)
+        else:
+            # Show image using Streamlit's default width handling or a fixed width
+            st.image(img, caption=f"Preview of {output_filename}", use_column_width='auto')
+
+    except Exception as e:
+        st.error(f"Could not display image preview: {e}")
+        st.warning("The image file might be corrupted or too large for preview.")
+
+
+def render_initial_info() -> None:
+    """
+    Displays the initial instructions and placeholder content when no file is uploaded.
+    """
+    st.info("👆 Upload a PDF file using the sidebar to get started.")
+    st.write("---")
+    # Placeholder or example section (optional)
+    # st.write("### Example Output Structure")
+    # st.image("https://via.placeholder.com/600x800/ccc/888?text=Page+1", caption="Page 1")
+    # st.image("https://via.placeholder.com/600x800/eee/777?text=Page+2", caption="Page 2")
+    # st.caption("...(Pages are stitched vertically)")
+
+def display_installation_info() -> None:
+    """Displays the installation requirements and run command."""
+    st.write("---")
+    with st.expander("🛠️ Installation & Usage"):
+        st.code("""
+# 1. Install required libraries
+pip install streamlit Pillow PyMuPDF
+
+# 2. Save the code files (app.py, pdf_processor.py, ui_components.py)
+#    in the same directory.
+
+# 3. Run the Streamlit application
+streamlit run app.py
+        """, language="bash")