Spaces:

nicoaspra
/

PDF-page-tiler

Sleeping

App Files Files Community

nicoaspra commited on Aug 25, 2025

Commit

e840a71

1 Parent(s): 11fa0df

initial commit

Browse files

Files changed (8) hide show

.gitignore +1 -0
README.md +4 -2
index.html +0 -19
index_card_merger.py +30 -0
style.css +0 -28
test.ipynb +117 -0
ui_PDF-booklet-tiler.py +320 -0
ui_index_card_merger.py +320 -0

.gitignore ADDED Viewed

	@@ -0,0 +1 @@


1	+ .DS_Store

README.md CHANGED Viewed

@@ -3,8 +3,10 @@ title: PDF Page Tiler
 emoji: ⚡
 colorFrom: yellow
 colorTo: red
-sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 emoji: ⚡
 colorFrom: yellow
 colorTo: red
+sdk: streamlit
+sdk_version: 1.40.1
+app_file: ui_PDF_booklet.py
 pinned: false
 ---

index.html DELETED Viewed

@@ -1,19 +0,0 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

index_card_merger.py ADDED Viewed

	@@ -0,0 +1,30 @@

+import PyPDF2
+from pdf2image import convert_from_path
+from PIL import Image
+# Step 1: Convert PDF pages to images
+pdf_path = '2425A.pdf'
+# pdf_path = 'index_cards.pdf'
+images = convert_from_path(pdf_path)
+# Step 2: Define the layout for the images (2x4 grid for 8 pages)
+rows, cols = 2, 4  # 2 rows, 4 columns
+thumbnail_width, thumbnail_height = 200, 300  # Thumbnail size for each page
+# Step 3: Create a blank canvas for the final merged image
+merged_image_width = thumbnail_width * cols
+merged_image_height = thumbnail_height * rows
+merged_image = Image.new('RGB', (merged_image_width, merged_image_height))
+# Step 4: Resize and paste each image onto the merged image
+for i, img in enumerate(images[:8]):  # Only process first 8 pages
+    img.thumbnail((thumbnail_width, thumbnail_height))
+    x = (i % cols) * thumbnail_width
+    y = (i // cols) * thumbnail_height
+    merged_image.paste(img, (x, y))
+# Step 5: Save the merged image
+merged_image.save('merged_image.png')
+# If you want to save the result back to PDF
+merged_image.save('merged_image.pdf', 'PDF', resolution=100.0)

style.css DELETED Viewed

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-.card p:last-child {
-	margin-bottom: 0;
-}

test.ipynb ADDED Viewed

	@@ -0,0 +1,117 @@

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All pages merged into PDFs/final_merged_document_with_blank_pages.pdf\n"
+     ]
+    }
+   ],
+   "source": [
+    "import math\n",
+    "import io\n",
+    "from pdf2image import convert_from_path\n",
+    "from PIL import Image\n",
+    "from PyPDF2 import PdfMerger\n",
+    "\n",
+    "# Path to the blank page PDF\n",
+    "blank_page_path = 'PDFs/blank.pdf'\n",
+    "\n",
+    "# Step 1: Convert PDF pages to high-quality images (set a higher DPI)\n",
+    "pdf_path = 'PDFs/index_cards.pdf'\n",
+    "images = convert_from_path(pdf_path, dpi=300)  # Increase DPI for better image quality\n",
+    "\n",
+    "# Step 2: Define the layout for the images (2x4 grid for 8 pages in landscape)\n",
+    "rows, cols = 2, 4  # 2 rows, 4 columns for landscape orientation\n",
+    "thumbnail_width, thumbnail_height = 3600 // cols, 2550 // rows  # Adjust the thumbnail size for landscape\n",
+    "\n",
+    "# Step 3: Prepare for multiple merged pages if there are more than 8 pages\n",
+    "num_pages = len(images)\n",
+    "pages_per_output = rows * cols  # 8 images per merged page (2x4 grid)\n",
+    "\n",
+    "# Calculate how many blank pages are needed\n",
+    "remainder = num_pages % pages_per_output\n",
+    "if remainder > 0:\n",
+    "    blank_pages_needed = pages_per_output - remainder  # How many blank pages are required\n",
+    "else:\n",
+    "    blank_pages_needed = 0\n",
+    "\n",
+    "# Step 4: Add the necessary number of blank images (blank pages)\n",
+    "if blank_pages_needed > 0:\n",
+    "    blank_image = convert_from_path(blank_page_path, dpi=300)[0]  # Convert blank.pdf to an image\n",
+    "    images.extend([blank_image] * blank_pages_needed)  # Add blank images to fill the remaining slots\n",
+    "\n",
+    "# Step 5: Process images in groups of 8 and create separate merged pages\n",
+    "num_output_pages = math.ceil(len(images) / pages_per_output)  # Total number of output PDF pages\n",
+    "\n",
+    "# Create a PdfMerger instance\n",
+    "merger = PdfMerger()\n",
+    "\n",
+    "for page_num in range(num_output_pages):\n",
+    "    # Create a new blank canvas for each output page\n",
+    "    merged_image = Image.new('RGB', (3600, 2550))  # 12 inches by 8.5 inches at 300 DPI\n",
+    "\n",
+    "    # Calculate the starting and ending image index for this output page\n",
+    "    start_index = page_num * pages_per_output\n",
+    "    end_index = min(start_index + pages_per_output, len(images))  # Ensure we don't exceed the image count\n",
+    "\n",
+    "    # # Top to Bottom\n",
+    "    # for i, img in enumerate(images[start_index:end_index]):\n",
+    "    #     img = img.resize((thumbnail_width, thumbnail_height), Image.Resampling.LANCZOS)  # High-quality resizing\n",
+    "    #     x = (i % cols) * thumbnail_width\n",
+    "    #     y = (i // cols) * thumbnail_height\n",
+    "    #     merged_image.paste(img, (x, y))\n",
+    "\n",
+    "    # Left to Right\n",
+    "    for i, img in enumerate(images[start_index:end_index]):\n",
+    "        img = img.resize((thumbnail_width, thumbnail_height), Image.Resampling.LANCZOS)  # High-quality resizing\n",
+    "        x = (i // rows) * thumbnail_width\n",
+    "        y = (i % rows) * thumbnail_height\n",
+    "        merged_image.paste(img, (x, y))\n",
+    "\n",
+    "    # Save the merged image to an in-memory buffer\n",
+    "    pdf_bytes = io.BytesIO()\n",
+    "    merged_image.save(pdf_bytes, format='PDF', resolution=300)\n",
+    "    pdf_bytes.seek(0)  # Move the pointer to the start of the BytesIO buffer\n",
+    "\n",
+    "    # Append the in-memory PDF to the PdfMerger\n",
+    "    merger.append(pdf_bytes)\n",
+    "\n",
+    "# Step 6: Save the final combined PDF\n",
+    "final_output_path = \"PDFs/final_merged_document_with_blank_pages.pdf\"\n",
+    "with open(final_output_path, 'wb') as f:\n",
+    "    merger.write(f)\n",
+    "merger.close()\n",
+    "\n",
+    "print(f\"All pages merged into {final_output_path}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "3.11.11",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

ui_PDF-booklet-tiler.py ADDED Viewed

	@@ -0,0 +1,320 @@

+# app.py
+from io import BytesIO
+from itertools import islice
+from typing import Iterable, List, Tuple
+import streamlit as st
+from PIL import Image, ImageOps, ImageDraw
+from pdf2image import convert_from_bytes, pdfinfo_from_bytes
+from pdf2image.exceptions import PDFInfoNotInstalledError, PDFPageCountError, PDFSyntaxError
+# ─────────────────────────────
+# Page config
+# ─────────────────────────────
+st.set_page_config(page_title="Class Card Layout Generator: PDF Page Tiler", page_icon="🧩", layout="wide")
+st.title("Class Card Layout Generator: PDF Page Tiler")
+# st.caption("Designed for faculty: simplify class card printing with customizable layouts that let you arrange, preview, and export class cards in seconds.")
+st.markdown("""
+**This tool streamlines the process of preparing class cards for printing.**
+It takes a single PDF of class cards and arranges the pages into customizable sheet layouts. With options for paper size, rows × columns, and margins, you can easily generate print-ready files tailored to your needs.
+**Ideal for faculty and educators,** this tool makes class card preparation faster, more efficient, and professional-looking. You can preview the layout instantly and export the results as PDFs or images, ready for distribution.
+""")
+st.markdown("### Instructions")
+st.markdown("""
+1. **Upload** a single PDF document containing your class cards.
+2. **Set** your preferred layout in the sidebar (paper size, rows × columns, margins, gutter).
+3. **Adjust** render DPI for print quality (300 recommended, 600 for extra sharp output).
+4. **Choose** which pages to include (all pages, first *n* pages, or a range).
+5. **Preview** the sheet using the preview slider.
+6. **Download** your output as a multi-page PDF (best for printing), a single PNG, or a ZIP of PNGs.
+""")
+# ─────────────────────────────
+# Sidebar
+# ─────────────────────────────
+with st.sidebar:
+    st.header("1) File")
+    pdf_file = st.file_uploader("Upload PDF", type=["pdf"])
+    st.header("2) Render")
+    render_dpi = st.slider("Render DPI (PDF ➜ images and sheet canvas DPI)", 96, 600, 300, step=12)
+    st.header("3) Sheet layout")
+    paper_preset = st.selectbox(
+        "Paper size preset",
+        [
+            "Short (8.5 × 11 in)",
+            "Folio / Legal (8.5 × 13 in)",
+            "A4 (8.27 × 11.69 in)",
+            "A5 (5.83 × 8.27 in)",
+            "A6 (4.13 × 5.83 in)",
+            "Custom Size (in)",
+        ],
+        index=0,
+    )
+    orientation = st.radio("Orientation", ["Portrait", "Landscape"], horizontal=True)
+    # Custom size fields side-by-side
+    custom_w_in = custom_h_in = None
+    if paper_preset == "Custom Size (in)":
+        cw, ch = st.columns(2)
+        with cw:
+            custom_w_in = st.number_input("Width (in)", 1.0, 30.0, 8.5, step=0.01)
+        with ch:
+            custom_h_in = st.number_input("Height (in)", 1.0, 30.0, 11.0, step=0.01)
+    # Margins & gutter side-by-side
+    mg, gt = st.columns(2)
+    with mg:
+        margin_in = st.number_input("Margins (in)", 0.0, 2.0, 0.00, step=0.05)
+    with gt:
+        gutter_in = st.number_input("Gutter (in)", 0.0, 1.0, 0.00, step=0.02)
+    # Rows & columns side-by-side
+    rc1, rc2 = st.columns(2)
+    with rc1:
+        rows = st.number_input("Rows", 1, 12, 2, step=1)
+    with rc2:
+        cols = st.number_input("Columns", 1, 12, 4, step=1)
+    st.header("4) Fit mode")
+    fit_mode = st.selectbox("Fit page into each cell", ["Contain (no crop)", "Cover (fill, may crop)"])
+    draw_cell_borders = st.checkbox("Debug: show cell borders", value=False)
+status = st.empty()
+controls = st.container()
+preview_slot = st.container()
+# ─────────────────────────────
+# Helpers
+# ─────────────────────────────
+PRESETS_INCHES: dict[str, Tuple[float, float]] = {
+    "Short (8.5 × 11 in)": (8.5, 11.0),
+    "Folio / Legal (8.5 × 13 in)": (8.5, 13.0),
+    "A4 (8.27 × 11.69 in)": (8.27, 11.69),
+    "A5 (5.83 × 8.27 in)": (5.83, 8.27),
+    "A6 (4.13 × 5.83 in)": (4.13, 5.83),
+}
+def resolve_paper_inches(preset: str, orientation: str, custom_w: float | None, custom_h: float | None) -> Tuple[float, float]:
+    if preset == "Custom Size (in)":
+        w, h = float(custom_w), float(custom_h)
+    else:
+        w, h = PRESETS_INCHES[preset]
+    if orientation == "Landscape":
+        w, h = h, w
+    return w, h
+def px(value_in_inches: float, dpi: int) -> int:
+    return max(1, int(round(value_in_inches * dpi)))
+def make_canvas_px(w_px: int, h_px: int, color=(255, 255, 255)) -> Image.Image:
+    return Image.new("RGB", (w_px, h_px), color=color)
+def fit_image(img: Image.Image, w: int, h: int, mode: str) -> Image.Image:
+    if mode.startswith("Contain"):
+        return ImageOps.contain(img, (w, h), method=Image.LANCZOS)
+    ratio = max(w / img.width, h / img.height)
+    new_w, new_h = int(img.width * ratio), int(img.height * ratio)
+    resized = img.resize((new_w, new_h), Image.LANCZOS)
+    x0 = (new_w - w) // 2
+    y0 = (new_h - h) // 2
+    return resized.crop((x0, y0, x0 + w, y0 + h))
+def chunk_iterable(iterable: Iterable, size: int):
+    it = iter(iterable)
+    while True:
+        chunk = list(islice(it, size))
+        if not chunk:
+            break
+        yield chunk
+def compose_sheet(page_imgs: List[Image.Image], rows: int, cols: int,
+                  sheet_w_px: int, sheet_h_px: int, margin_px: int, gutter_px: int,
+                  fit_mode: str, show_borders: bool = False) -> Image.Image:
+    inner_w = sheet_w_px - 2 * margin_px
+    inner_h = sheet_h_px - 2 * margin_px
+    cell_w = (inner_w - (cols - 1) * gutter_px) // cols
+    cell_h = (inner_h - (rows - 1) * gutter_px) // rows
+    canvas = make_canvas_px(sheet_w_px, sheet_h_px, color=(255, 255, 255))
+    draw = ImageDraw.Draw(canvas)
+    for idx, img in enumerate(page_imgs[: rows * cols]):
+        r, c = divmod(idx, cols)
+        x = margin_px + c * (cell_w + gutter_px)
+        y = margin_px + r * (cell_h + gutter_px)
+        fitted = fit_image(img, cell_w, cell_h, fit_mode)
+        canvas.paste(fitted, (x, y))
+        if show_borders:
+            draw.rectangle([x, y, x + cell_w, y + cell_h], outline=(0, 0, 0), width=2)
+    return canvas
+def build_sheets(images: List[Image.Image], rows: int, cols: int,
+                 sheet_w_px: int, sheet_h_px: int, margin_px: int, gutter_px: int,
+                 fit_mode: str, show_borders: bool = False) -> List[Image.Image]:
+    per_sheet = rows * cols
+    sheets: List[Image.Image] = []
+    for group in chunk_iterable(images, per_sheet):
+        sheet = compose_sheet(group, rows, cols, sheet_w_px, sheet_h_px,
+                              margin_px, gutter_px, fit_mode, show_borders)
+        if sheet.mode != "RGB":
+            sheet = sheet.convert("RGB")
+        sheets.append(sheet)
+    return sheets
+def sheets_to_pdf_bytes(sheets: List[Image.Image], dpi: int = 300) -> bytes:
+    buf = BytesIO()
+    if len(sheets) == 1:
+        sheets[0].save(buf, format="PDF", resolution=dpi)
+    else:
+        sheets[0].save(buf, format="PDF", save_all=True, append_images=sheets[1:], resolution=dpi)
+    buf.seek(0)
+    return buf.getvalue()
+def to_png_bytes(img: Image.Image) -> bytes:
+    buf = BytesIO()
+    img.save(buf, "PNG")
+    buf.seek(0)
+    return buf.getvalue()
+def build_zip_bytes(imgs: List[Image.Image]) -> bytes:
+    from zipfile import ZipFile, ZIP_DEFLATED
+    bio = BytesIO()
+    with ZipFile(bio, "w", ZIP_DEFLATED) as zf:
+        for i, im in enumerate(imgs, start=1):
+            buf = BytesIO()
+            im.save(buf, "PNG")
+            buf.seek(0)
+            zf.writestr(f"sheet_{i}.png", buf.read())
+    bio.seek(0)
+    return bio.getvalue()
+# ─────────────────────────────
+# Main
+# ─────────────────────────────
+if not pdf_file:
+    status.info("Upload a PDF in the sidebar to begin.")
+    st.stop()
+try:
+    pdf_bytes = pdf_file.read()
+    status.info("Inspecting PDF and environment…")
+    try:
+        info = pdfinfo_from_bytes(pdf_bytes, poppler_path=None)
+        n_pages = int(info.get("Pages", 0))
+        st.write(f"**Detected {n_pages} page(s).**")
+    except PDFInfoNotInstalledError:
+        st.error(
+            "Poppler is not installed or not found on PATH. "
+            "Install it (macOS: `brew install poppler`, Ubuntu: `sudo apt-get install poppler-utils`, "
+            "Windows: download Poppler and add its `bin` folder to PATH)."
+        )
+        st.stop()
+    # Page selection
+    with controls:
+        st.subheader("Page selection")
+        mode = st.radio("Choose pages", ["All", "First n Pages", "Range"], horizontal=True, key="mode_radio")
+        first_n = None
+        fp = None
+        lp = None
+        if mode == "First n Pages":
+            first_n = st.number_input("First N pages", 1, n_pages, n_pages, step=1, key="firstn")
+        elif mode == "Range":
+            fp = st.number_input("First page (1-based)", 1, n_pages, 1, step=1, key="fp")
+            lp = st.number_input("Last page (inclusive)", 1, n_pages, n_pages, step=1, key="lp")
+    first_page, last_page = 1, None
+    if mode == "First n Pages" and first_n:
+        first_page, last_page = 1, int(first_n)
+    elif mode == "Range" and fp and lp:
+        first_page, last_page = int(fp), int(lp)
+        if last_page < first_page:
+            first_page, last_page = last_page, first_page
+            st.warning("Swapped page range so First ≤ Last.")
+    status.info("Rendering PDF pages ➜ images…")
+    images = convert_from_bytes(
+        pdf_bytes,
+        dpi=render_dpi,
+        first_page=first_page,
+        last_page=last_page,
+        poppler_path=None,
+    )
+    if not images:
+        st.error("No pages were rendered — check your page selection.")
+        st.stop()
+    # Resolve paper inches
+    w_in, h_in = resolve_paper_inches(paper_preset, orientation, custom_w_in, custom_h_in)
+    # Compute sheet pixel size
+    sheet_w_px = px(w_in, render_dpi)
+    sheet_h_px = px(h_in, render_dpi)
+    margin_px = px(margin_in, render_dpi)
+    gutter_px = px(gutter_in, render_dpi)
+    status.info("Composing sheets…")
+    sheets = build_sheets(
+        images=images,
+        rows=int(rows),
+        cols=int(cols),
+        sheet_w_px=sheet_w_px,
+        sheet_h_px=sheet_h_px,
+        margin_px=margin_px,
+        gutter_px=gutter_px,
+        fit_mode=fit_mode,
+        show_borders=draw_cell_borders,
+    )
+    status.success(f"Built {len(sheets)} sheet(s) at {render_dpi} DPI.")
+    # Preview slider
+    sel = st.slider("Preview sheet", 1, len(sheets), 1, step=1) if len(sheets) > 1 else 1
+    preview = sheets[sel - 1]
+    with preview_slot:
+        st.image(preview, caption=f"Preview (sheet {sel} of {len(sheets)})", use_container_width=True)
+    # Downloads
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        pdf_bytes_all = sheets_to_pdf_bytes(sheets, dpi=render_dpi)
+        st.download_button(
+            "Download PDF (all sheets)",
+            data=pdf_bytes_all,
+            file_name="nup_all_sheets.pdf",
+            mime="application/pdf",
+            type="primary",   # highlight main action
+        )
+    with c2:
+        st.download_button(
+            f"Download PNG (sheet {sel})",
+            data=to_png_bytes(preview),
+            file_name=f"sheet_{sel}.png",
+            mime="image/png",
+        )
+    with c3:
+        zip_bytes = build_zip_bytes(sheets)
+        st.download_button(
+            "Download ZIP (all sheets as PNG)",
+            data=zip_bytes,
+            file_name="nup_all_sheets_png.zip",
+            mime="application/zip",
+        )
+except (PDFPageCountError, PDFSyntaxError):
+    st.error("The PDF seems corrupted or password-protected.")
+# streamlit run 240818_index_card_merger/ui_index_card_merger.py

ui_index_card_merger.py ADDED Viewed

	@@ -0,0 +1,320 @@

+# app.py
+from io import BytesIO
+from itertools import islice
+from typing import Iterable, List, Tuple
+import streamlit as st
+from PIL import Image, ImageOps, ImageDraw
+from pdf2image import convert_from_bytes, pdfinfo_from_bytes
+from pdf2image.exceptions import PDFInfoNotInstalledError, PDFPageCountError, PDFSyntaxError
+# ─────────────────────────────
+# Page config
+# ─────────────────────────────
+st.set_page_config(page_title="Class Card Layout Generator: PDF Page Tiler", page_icon="🧩", layout="wide")
+st.title("Class Card Layout Generator: PDF Page Tiler")
+# st.caption("Designed for faculty: simplify class card printing with customizable layouts that let you arrange, preview, and export class cards in seconds.")
+st.markdown("""
+**This tool streamlines the process of preparing class cards for printing.**
+It takes a single PDF of class cards and arranges the pages into customizable sheet layouts. With options for paper size, rows × columns, and margins, you can easily generate print-ready files tailored to your needs.
+**Ideal for faculty and educators,** this tool makes class card preparation faster, more efficient, and professional-looking. You can preview the layout instantly and export the results as PDFs or images, ready for distribution.
+""")
+st.markdown("### Instructions")
+st.markdown("""
+1. **Upload** a single PDF document containing your class cards.
+2. **Set** your preferred layout in the sidebar (paper size, rows × columns, margins, gutter).
+3. **Adjust** render DPI for print quality (300 recommended, 600 for extra sharp output).
+4. **Choose** which pages to include (all pages, first *n* pages, or a range).
+5. **Preview** the sheet using the preview slider.
+6. **Download** your output as a multi-page PDF (best for printing), a single PNG, or a ZIP of PNGs.
+""")
+# ─────────────────────────────
+# Sidebar
+# ─────────────────────────────
+with st.sidebar:
+    st.header("1) File")
+    pdf_file = st.file_uploader("Upload PDF", type=["pdf"])
+    st.header("2) Render")
+    render_dpi = st.slider("Render DPI (PDF ➜ images and sheet canvas DPI)", 96, 600, 300, step=12)
+    st.header("3) Sheet layout")
+    paper_preset = st.selectbox(
+        "Paper size preset",
+        [
+            "Short (8.5 × 11 in)",
+            "Folio / Legal (8.5 × 13 in)",
+            "A4 (8.27 × 11.69 in)",
+            "A5 (5.83 × 8.27 in)",
+            "A6 (4.13 × 5.83 in)",
+            "Custom Size (in)",
+        ],
+        index=0,
+    )
+    orientation = st.radio("Orientation", ["Portrait", "Landscape"], horizontal=True)
+    # Custom size fields side-by-side
+    custom_w_in = custom_h_in = None
+    if paper_preset == "Custom Size (in)":
+        cw, ch = st.columns(2)
+        with cw:
+            custom_w_in = st.number_input("Width (in)", 1.0, 30.0, 8.5, step=0.01)
+        with ch:
+            custom_h_in = st.number_input("Height (in)", 1.0, 30.0, 11.0, step=0.01)
+    # Margins & gutter side-by-side
+    mg, gt = st.columns(2)
+    with mg:
+        margin_in = st.number_input("Margins (in)", 0.0, 2.0, 0.00, step=0.05)
+    with gt:
+        gutter_in = st.number_input("Gutter (in)", 0.0, 1.0, 0.00, step=0.02)
+    # Rows & columns side-by-side
+    rc1, rc2 = st.columns(2)
+    with rc1:
+        rows = st.number_input("Rows", 1, 12, 2, step=1)
+    with rc2:
+        cols = st.number_input("Columns", 1, 12, 4, step=1)
+    st.header("4) Fit mode")
+    fit_mode = st.selectbox("Fit page into each cell", ["Contain (no crop)", "Cover (fill, may crop)"])
+    draw_cell_borders = st.checkbox("Debug: show cell borders", value=False)
+status = st.empty()
+controls = st.container()
+preview_slot = st.container()
+# ─────────────────────────────
+# Helpers
+# ─────────────────────────────
+PRESETS_INCHES: dict[str, Tuple[float, float]] = {
+    "Short (8.5 × 11 in)": (8.5, 11.0),
+    "Folio / Legal (8.5 × 13 in)": (8.5, 13.0),
+    "A4 (8.27 × 11.69 in)": (8.27, 11.69),
+    "A5 (5.83 × 8.27 in)": (5.83, 8.27),
+    "A6 (4.13 × 5.83 in)": (4.13, 5.83),
+}
+def resolve_paper_inches(preset: str, orientation: str, custom_w: float | None, custom_h: float | None) -> Tuple[float, float]:
+    if preset == "Custom Size (in)":
+        w, h = float(custom_w), float(custom_h)
+    else:
+        w, h = PRESETS_INCHES[preset]
+    if orientation == "Landscape":
+        w, h = h, w
+    return w, h
+def px(value_in_inches: float, dpi: int) -> int:
+    return max(1, int(round(value_in_inches * dpi)))
+def make_canvas_px(w_px: int, h_px: int, color=(255, 255, 255)) -> Image.Image:
+    return Image.new("RGB", (w_px, h_px), color=color)
+def fit_image(img: Image.Image, w: int, h: int, mode: str) -> Image.Image:
+    if mode.startswith("Contain"):
+        return ImageOps.contain(img, (w, h), method=Image.LANCZOS)
+    ratio = max(w / img.width, h / img.height)
+    new_w, new_h = int(img.width * ratio), int(img.height * ratio)
+    resized = img.resize((new_w, new_h), Image.LANCZOS)
+    x0 = (new_w - w) // 2
+    y0 = (new_h - h) // 2
+    return resized.crop((x0, y0, x0 + w, y0 + h))
+def chunk_iterable(iterable: Iterable, size: int):
+    it = iter(iterable)
+    while True:
+        chunk = list(islice(it, size))
+        if not chunk:
+            break
+        yield chunk
+def compose_sheet(page_imgs: List[Image.Image], rows: int, cols: int,
+                  sheet_w_px: int, sheet_h_px: int, margin_px: int, gutter_px: int,
+                  fit_mode: str, show_borders: bool = False) -> Image.Image:
+    inner_w = sheet_w_px - 2 * margin_px
+    inner_h = sheet_h_px - 2 * margin_px
+    cell_w = (inner_w - (cols - 1) * gutter_px) // cols
+    cell_h = (inner_h - (rows - 1) * gutter_px) // rows
+    canvas = make_canvas_px(sheet_w_px, sheet_h_px, color=(255, 255, 255))
+    draw = ImageDraw.Draw(canvas)
+    for idx, img in enumerate(page_imgs[: rows * cols]):
+        r, c = divmod(idx, cols)
+        x = margin_px + c * (cell_w + gutter_px)
+        y = margin_px + r * (cell_h + gutter_px)
+        fitted = fit_image(img, cell_w, cell_h, fit_mode)
+        canvas.paste(fitted, (x, y))
+        if show_borders:
+            draw.rectangle([x, y, x + cell_w, y + cell_h], outline=(0, 0, 0), width=2)
+    return canvas
+def build_sheets(images: List[Image.Image], rows: int, cols: int,
+                 sheet_w_px: int, sheet_h_px: int, margin_px: int, gutter_px: int,
+                 fit_mode: str, show_borders: bool = False) -> List[Image.Image]:
+    per_sheet = rows * cols
+    sheets: List[Image.Image] = []
+    for group in chunk_iterable(images, per_sheet):
+        sheet = compose_sheet(group, rows, cols, sheet_w_px, sheet_h_px,
+                              margin_px, gutter_px, fit_mode, show_borders)
+        if sheet.mode != "RGB":
+            sheet = sheet.convert("RGB")
+        sheets.append(sheet)
+    return sheets
+def sheets_to_pdf_bytes(sheets: List[Image.Image], dpi: int = 300) -> bytes:
+    buf = BytesIO()
+    if len(sheets) == 1:
+        sheets[0].save(buf, format="PDF", resolution=dpi)
+    else:
+        sheets[0].save(buf, format="PDF", save_all=True, append_images=sheets[1:], resolution=dpi)
+    buf.seek(0)
+    return buf.getvalue()
+def to_png_bytes(img: Image.Image) -> bytes:
+    buf = BytesIO()
+    img.save(buf, "PNG")
+    buf.seek(0)
+    return buf.getvalue()
+def build_zip_bytes(imgs: List[Image.Image]) -> bytes:
+    from zipfile import ZipFile, ZIP_DEFLATED
+    bio = BytesIO()
+    with ZipFile(bio, "w", ZIP_DEFLATED) as zf:
+        for i, im in enumerate(imgs, start=1):
+            buf = BytesIO()
+            im.save(buf, "PNG")
+            buf.seek(0)
+            zf.writestr(f"sheet_{i}.png", buf.read())
+    bio.seek(0)
+    return bio.getvalue()
+# ─────────────────────────────
+# Main
+# ─────────────────────────────
+if not pdf_file:
+    status.info("Upload a PDF in the sidebar to begin.")
+    st.stop()
+try:
+    pdf_bytes = pdf_file.read()
+    status.info("Inspecting PDF and environment…")
+    try:
+        info = pdfinfo_from_bytes(pdf_bytes, poppler_path=None)
+        n_pages = int(info.get("Pages", 0))
+        st.write(f"**Detected {n_pages} page(s).**")
+    except PDFInfoNotInstalledError:
+        st.error(
+            "Poppler is not installed or not found on PATH. "
+            "Install it (macOS: `brew install poppler`, Ubuntu: `sudo apt-get install poppler-utils`, "
+            "Windows: download Poppler and add its `bin` folder to PATH)."
+        )
+        st.stop()
+    # Page selection
+    with controls:
+        st.subheader("Page selection")
+        mode = st.radio("Choose pages", ["All", "First n Pages", "Range"], horizontal=True, key="mode_radio")
+        first_n = None
+        fp = None
+        lp = None
+        if mode == "First n Pages":
+            first_n = st.number_input("First N pages", 1, n_pages, n_pages, step=1, key="firstn")
+        elif mode == "Range":
+            fp = st.number_input("First page (1-based)", 1, n_pages, 1, step=1, key="fp")
+            lp = st.number_input("Last page (inclusive)", 1, n_pages, n_pages, step=1, key="lp")
+    first_page, last_page = 1, None
+    if mode == "First n Pages" and first_n:
+        first_page, last_page = 1, int(first_n)
+    elif mode == "Range" and fp and lp:
+        first_page, last_page = int(fp), int(lp)
+        if last_page < first_page:
+            first_page, last_page = last_page, first_page
+            st.warning("Swapped page range so First ≤ Last.")
+    status.info("Rendering PDF pages ➜ images…")
+    images = convert_from_bytes(
+        pdf_bytes,
+        dpi=render_dpi,
+        first_page=first_page,
+        last_page=last_page,
+        poppler_path=None,
+    )
+    if not images:
+        st.error("No pages were rendered — check your page selection.")
+        st.stop()
+    # Resolve paper inches
+    w_in, h_in = resolve_paper_inches(paper_preset, orientation, custom_w_in, custom_h_in)
+    # Compute sheet pixel size
+    sheet_w_px = px(w_in, render_dpi)
+    sheet_h_px = px(h_in, render_dpi)
+    margin_px = px(margin_in, render_dpi)
+    gutter_px = px(gutter_in, render_dpi)
+    status.info("Composing sheets…")
+    sheets = build_sheets(
+        images=images,
+        rows=int(rows),
+        cols=int(cols),
+        sheet_w_px=sheet_w_px,
+        sheet_h_px=sheet_h_px,
+        margin_px=margin_px,
+        gutter_px=gutter_px,
+        fit_mode=fit_mode,
+        show_borders=draw_cell_borders,
+    )
+    status.success(f"Built {len(sheets)} sheet(s) at {render_dpi} DPI.")
+    # Preview slider
+    sel = st.slider("Preview sheet", 1, len(sheets), 1, step=1) if len(sheets) > 1 else 1
+    preview = sheets[sel - 1]
+    with preview_slot:
+        st.image(preview, caption=f"Preview (sheet {sel} of {len(sheets)})", use_container_width=True)
+    # Downloads
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        pdf_bytes_all = sheets_to_pdf_bytes(sheets, dpi=render_dpi)
+        st.download_button(
+            "Download PDF (all sheets)",
+            data=pdf_bytes_all,
+            file_name="nup_all_sheets.pdf",
+            mime="application/pdf",
+            type="primary",   # highlight main action
+        )
+    with c2:
+        st.download_button(
+            f"Download PNG (sheet {sel})",
+            data=to_png_bytes(preview),
+            file_name=f"sheet_{sel}.png",
+            mime="image/png",
+        )
+    with c3:
+        zip_bytes = build_zip_bytes(sheets)
+        st.download_button(
+            "Download ZIP (all sheets as PNG)",
+            data=zip_bytes,
+            file_name="nup_all_sheets_png.zip",
+            mime="application/zip",
+        )
+except (PDFPageCountError, PDFSyntaxError):
+    st.error("The PDF seems corrupted or password-protected.")
+# streamlit run 240818_index_card_merger/ui_index_card_merger.py