scripts/build_reference_pdf.py

#!/usr/bin/env python3
"""Render the dataset as a printable dimensional reference.

Everything on the page comes from containers.csv and listings.csv — nothing is
typed here — so the PDF cannot drift from the data. Per-vendor internal
dimensions come from container_stats, the same module build.py uses, so the
variance tables and the CSV's vendor_capacity_* columns are computed once.

Output: reference/storage-container-reference.pdf

Needs reportlab (pip install -r scripts/requirements.txt).
Run: python3 scripts/build_reference_pdf.py
"""

import csv
import sys
from datetime import date
from pathlib import Path

from reportlab.lib import colors
from reportlab.lib.enums import TA_LEFT
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
from reportlab.lib.units import mm
from reportlab.platypus import (BaseDocTemplate, Frame, KeepTogether, NextPageTemplate,
                                PageBreak, PageTemplate, Paragraph, Spacer, Table,
                                TableStyle)

HERE = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(HERE))
import container_stats  # noqa: E402  (needs HERE on the path)

OUT = HERE / "reference" / "storage-container-reference.pdf"
DATASET_URL = "https://huggingface.co/datasets/danielrosehill/storage-container-dimensions"

INK = colors.HexColor("#1f2933")
MUTED = colors.HexColor("#6b7480")
RULE = colors.HexColor("#c9d1d9")
BAND = colors.HexColor("#f2f4f6")
HEAD_BG = colors.HexColor("#26323d")

FAMILY_ORDER = ["euro_stacking_container", "attached_lid_container", "vda_klt_container"]
FAMILY_TITLES = {
    "euro_stacking_container": "Euro stacking containers",
    "attached_lid_container": "Attached-lid containers (ALC)",
    "vda_klt_container": "VDA 4500 KLTs",
}
# One line each, so a reader who opens on this page knows what the family is.
FAMILY_BLURB = {
    "euro_stacking_container":
        "Open top, straight walls, lid a separate purchase. Stack when full; they do "
        "not nest when empty. No standard fixes the height series — it is whatever "
        "manufacturers converged on.",
    "attached_lid_container":
        "Integral hinged lid, walls sloping inward towards the base. Stack when full "
        "and nest to about 75 % of their height when empty. Capacities are the "
        "manufacturers' nominal figures: the taper means no single internal "
        "measurement is right at more than one height.",
    "vda_klt_container":
        "Returnable small load carriers for automotive supply chains. VDA 4500 fixes "
        "three external heights — 147.5, 213 and 280 mm — and thicker walls than a "
        "consumer eurobox, so the eurobox internal rule does not transfer.",
}


def styles():
    ss = getSampleStyleSheet()
    base = dict(fontName="Helvetica", textColor=INK, alignment=TA_LEFT)
    return {
        "title": ParagraphStyle("t", fontName="Helvetica-Bold", fontSize=26, leading=30,
                                textColor=INK, spaceAfter=2, alignment=TA_LEFT),
        "subtitle": ParagraphStyle("st", fontName="Helvetica", fontSize=12.5, leading=17,
                                   textColor=MUTED, spaceAfter=18, alignment=TA_LEFT),
        "h1": ParagraphStyle("h1", fontName="Helvetica-Bold", fontSize=16, leading=20,
                             textColor=INK, spaceBefore=2, spaceAfter=6),
        "h2": ParagraphStyle("h2", fontName="Helvetica-Bold", fontSize=11, leading=14,
                             textColor=INK, spaceBefore=12, spaceAfter=5),
        "body": ParagraphStyle("b", fontSize=9.2, leading=13, spaceAfter=7, **base),
        "note": ParagraphStyle("n", fontSize=8, leading=11, textColor=MUTED,
                               spaceAfter=9, fontName="Helvetica", alignment=TA_LEFT),
        "cell": ParagraphStyle("c", fontSize=7.6, leading=9.6, **base),
    }


S = styles()


def para(text, style="body"):
    return Paragraph(text, S[style])


def table(data, widths, align_right=(), small=False):
    t = Table(data, colWidths=widths, repeatRows=1, hAlign="LEFT")
    size = 7.2 if small else 7.8
    cmds = [
        ("BACKGROUND", (0, 0), (-1, 0), HEAD_BG),
        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
        ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
        ("FONTNAME", (0, 1), (-1, -1), "Helvetica"),
        ("FONTSIZE", (0, 0), (-1, -1), size),
        ("LEADING", (0, 0), (-1, -1), size + 2.6),
        ("TEXTCOLOR", (0, 1), (-1, -1), INK),
        ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
        ("TOPPADDING", (0, 0), (-1, -1), 3.2),
        ("BOTTOMPADDING", (0, 0), (-1, -1), 3.2),
        ("LEFTPADDING", (0, 0), (-1, -1), 5),
        ("RIGHTPADDING", (0, 0), (-1, -1), 5),
        ("LINEBELOW", (0, 0), (-1, -1), 0.25, RULE),
        ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, BAND]),
    ]
    for col in align_right:
        cmds.append(("ALIGN", (col, 1), (col, -1), "RIGHT"))
    t.setStyle(TableStyle(cmds))
    return t


def load(name):
    with (HERE / name).open(encoding="utf-8") as f:
        return list(csv.DictReader(f))


def num(v, dp=1):
    """CSV cell -> display string. Empty stays empty; integers lose the .0."""
    if v in ("", None):
        return "—"
    f = float(v)
    return str(int(f)) if f == int(f) and dp == 1 else f"{f:.{dp}f}"


def group_by_footprint(rows):
    """Footprint -> its sizes, in the order the dataset lists them.

    Not sorted: the dataset leads with 600x400 because that is the footprint
    everything else is a fraction or multiple of, and a reference should open on
    the size the reader most likely came for.
    """
    out = {}
    for r in rows:
        out.setdefault((float(r["external_length_cm"]), float(r["external_width_cm"])), []).append(r)
    return out


# ---------------------------------------------------------------------------
# Page furniture
# ---------------------------------------------------------------------------

def page_decoration(canvas, doc):
    canvas.saveState()
    canvas.setFont("Helvetica", 7.2)
    canvas.setFillColor(MUTED)
    canvas.drawString(20 * mm, 12 * mm, "Industrial storage containers — dimensional reference")
    canvas.drawRightString(A4[0] - 20 * mm, 12 * mm, f"page {canvas.getPageNumber()}")
    canvas.setStrokeColor(RULE)
    canvas.setLineWidth(0.4)
    canvas.line(20 * mm, 15 * mm, A4[0] - 20 * mm, 15 * mm)
    canvas.restoreState()


def build_doc():
    doc = BaseDocTemplate(str(OUT), pagesize=A4,
                          leftMargin=20 * mm, rightMargin=20 * mm,
                          topMargin=18 * mm, bottomMargin=20 * mm,
                          title="Industrial storage containers — dimensional reference",
                          author="Daniel Rosehill", subject="Container dimensions and capacities")
    frame = Frame(doc.leftMargin, doc.bottomMargin, doc.width, doc.height, id="body")
    doc.addPageTemplates([
        PageTemplate(id="cover", frames=[frame]),
        PageTemplate(id="body", frames=[frame], onPage=page_decoration),
    ])
    return doc


# ---------------------------------------------------------------------------
# Content
# ---------------------------------------------------------------------------

def cover(containers, listings, verified):
    n_vendors = len({r["vendor"] for r in listings})
    markets = len({r["vendor_country"] for r in listings})
    return [
        Spacer(1, 40 * mm),
        para("Industrial storage containers", "title"),
        para("A dimensional reference: Euroboxes, attached-lid containers and VDA KLTs", "subtitle"),
        table([
            ["Container sizes", str(len(containers))],
            ["Vendor listings behind them", f"{len(listings)} from {n_vendors} vendors in {markets} markets"],
            ["Data verified", verified],
            ["Generated", date.today().isoformat()],
            ["Source", DATASET_URL],
            ["Licence", "CC BY 4.0"],
        ], [45 * mm, 125 * mm]),
        Spacer(1, 10 * mm),
        para(
            "Multiply a container's external dimensions and you will overstate what you are "
            "buying by roughly a quarter — and you will overstate a tapered attached-lid "
            "container by more than a straight-walled eurobox, which quietly corrupts any "
            "comparison between the two. Every capacity in this document is usable capacity. "
            "External volume is shown alongside so the gap stays visible."),
        para(
            "Nothing here is typed by hand: every figure is rendered from the published "
            "dataset. Where vendors disagree — and on internal dimensions they disagree a "
            "great deal — the disagreement is printed rather than averaged away."),
    ]


def how_to_read():
    return [
        NextPageTemplate("body"), PageBreak(),
        para("How to read these tables", "h1"),
        para(
            "<b>The standards fix external dimensions. They do not fix internal ones.</b> "
            "ISO 3394 defines the 600 × 400 mm packaging module, EN 13199 caps a small load "
            "carrier at that footprint, and VDA 4500 additionally fixes three external "
            "heights. None of them specifies wall thickness, draft angle, rib design or base "
            "construction — and those are what determine what fits inside."),
        para("So each size carries three capacity figures, not one:"),
        table([
            ["Column", "What it is", "Use it for"],
            [para("<b>Typical usable</b>", "cell"),
             para("Computed from a conservative internal footprint: for a 600 × 400 box, "
                  "550 × 355 mm and 15 mm off the height. At or just below the least "
                  "generous vendor.", "cell"),
             para("Planning. A figure that overstates capacity fails silently — the pallet "
                  "does not fit, the shipment does not close.", "cell")],
            [para("<b>Vendor range</b>", "cell"),
             para("Capacity implied by each vendor's own published internal dimensions for "
                  "that footprint, lowest to highest. One vote per vendor, not per listing.", "cell"),
             para("Knowing what you will be quoted, and how much of a quoted difference is "
                  "real rather than measurement convention.", "cell")],
            [para("<b>External</b>", "cell"),
             para("L × W × H. What the box occupies on a shelf or in a container.", "cell"),
             para("Space planning, freight, pallet build.", "cell")],
        ], [26 * mm, 74 * mm, 70 * mm]),
        para("Why the vendor range is so wide", "h2"),
        para(
            "Because vendors measure at different heights. A euro crate is slightly tapered, "
            "so its top opening is larger than its base. Salesbridges publishes the top "
            "opening (570 × 370 mm inside a 600 × 400 box); Plastic Box Shop and Yosibox "
            "publish something close to the base (555 × 355 and 550 × 360). All three are "
            "honest, and the spread between them is about 11 % in litres on the same box. "
            "Each family section below prints the per-vendor figures it was drawn from."),
        para("A note on names", "h2"),
        para(
            "The trade has no agreed vocabulary. The same box is a Eurobox, a euro crate, a "
            "stacking tote, an industrial tote or a “KLT box” depending on the seller, and "
            "two of those mislead: “KLT” is widely applied to ordinary euroboxes that are "
            "nowhere near the VDA height grid, and “tote” means any industrial container in "
            "US usage but leans towards the attached-lid product in the UK. The last page "
            "lists the aliases by market. Identify a box by its walls, its lid and whether it "
            "nests — never by its name."),
    ]


def sizes_table(rows, family):
    """One row per height. External L x W is in the heading, so it is not repeated."""
    header = ["H (cm)", "Internal, typical\n(L × W × H cm)", "External\nvolume (L)",
              "Typical\nusable (L)", "Vendor range (L)", "Usable\n%", "Per EUR-1\nlayer",
              "Listings\nseen"]
    body = []
    for r in rows:
        lo, hi = r["vendor_capacity_low_l"], r["vendor_capacity_high_l"]
        rng = "—" if lo == "" else (num(lo) if lo == hi else f"{num(lo)} – {num(hi)}")
        internal = "—" if not r["internal_length_cm"] else (
            f'{num(r["internal_length_cm"])} × {num(r["internal_width_cm"])} '
            f'× {num(r["internal_height_cm"])}')
        body.append([
            num(r["external_height_cm"]),
            internal,
            num(r["external_volume_l"]),
            num(r["typical_capacity_l"]),
            rng,
            f'{float(r["usable_ratio"]) * 100:.0f}',
            r["eur1_pallet_per_layer"],
            r["listings_observed"],
        ])
    widths = [16 * mm, 35 * mm, 21 * mm, 21 * mm, 26 * mm, 14 * mm, 19 * mm, 18 * mm]
    return table([header] + body, widths, align_right=(0, 2, 3, 4, 5, 6, 7))


def variance_block(kind, L, W, index, counts):
    """Per-vendor published internal dimensions for one footprint."""
    key = (kind, round(L * 10), round(W * 10))
    vendors = index.get(key)
    if not vendors:
        return [para(
            "No vendor in the captured listings publishes internal dimensions for this "
            "footprint, so no vendor range is shown above.", "note")]

    header = ["Vendor", "Listings", "Internal L × W (mm)", "Wall allowance\nper side (mm)",
              "External − internal\nheight (mm)", "Reading"]
    body = []
    for vendor in sorted(vendors, key=lambda v: -vendors[v][0]):
        il, iw, ded = vendors[vendor]
        per_side = ((L * 10 - il) / 2 + (W * 10 - iw) / 2) / 2
        # ~15 mm a side is a top-opening measurement; ~22 mm and up is near the base.
        reading = "top opening" if per_side < 20 else "near the base"
        body.append([vendor, str(counts.get(key, {}).get(vendor, 0)),
                     f"{il:.0f} × {iw:.0f}", f"{per_side:.0f}", f"{ded:.0f}", reading])
    widths = [34 * mm, 16 * mm, 30 * mm, 27 * mm, 32 * mm, 31 * mm]
    return [table([header] + body, widths, align_right=(1, 3, 4), small=True), Spacer(1, 4 * mm)]


VARIANCE_NOTE = (
    "Under each footprint: what each vendor publishes as the inside of that box. Wall "
    "allowance is (external − internal) ÷ 2, averaged over length and width. A figure near "
    "15 mm is a top-opening measurement; 22 mm and above is measured close to the base. The "
    "difference between those two conventions, not manufacturing variation, is most of the "
    "vendor range.")


def family_section(kind, containers, index, counts):
    rows = [r for r in containers if r["type"] == kind]
    flow = [NextPageTemplate("body"), PageBreak(),
            para(FAMILY_TITLES[kind], "h1"), para(FAMILY_BLURB[kind])]
    if any((kind, round(L * 10), round(W * 10)) in index
           for L, W in group_by_footprint(rows)):
        flow.append(para(VARIANCE_NOTE, "note"))
    for (L, W), sizes in group_by_footprint(rows).items():
        block = [para(f"{num(L)} × {num(W)} cm", "h2"), sizes_table(sizes, kind)]
        flow.append(KeepTogether(block))
        flow.append(Spacer(1, 3 * mm))
        flow.extend(variance_block(kind, L, W, index, counts))
    return flow


def sources_page(listings):
    by_vendor = {}
    for r in listings:
        v = by_vendor.setdefault(r["vendor"], {"n": 0, "internal": 0, "country": r["vendor_country"],
                                               "date": r["captured_date"], "cur": r["currency"]})
        v["n"] += 1
        v["internal"] += 1 if r["internal_length_cm"] else 0

    header = ["Vendor", "Market", "Listings", "With published\ninternals", "Currency", "Captured"]
    body = [[k, v["country"], str(v["n"]), str(v["internal"]), v["cur"], v["date"]]
            for k, v in sorted(by_vendor.items(), key=lambda kv: -kv[1]["n"])]

    ratios = {}
    for r in listings:
        if r["usable_ratio"]:
            ratios.setdefault(r["type"], []).append(float(r["usable_ratio"]))
    stat_rows = []
    for kind in FAMILY_ORDER:
        v = sorted(ratios.get(kind, []))
        if not v:
            continue
        stat_rows.append([FAMILY_TITLES[kind], str(len(v)), f"{min(v):.0%}",
                          f"{container_stats.median(v):.0%}", f"{max(v):.0%}"])

    return [
        NextPageTemplate("body"), PageBreak(),
        para("Where the numbers come from", "h1"),
        para(
            "Vendor catalogues captured on the dates below, plus VDA 4500 v3.1 for the KLT "
            "grid and secondary summaries of ISO 3394 and EN 13199, both of which are paid "
            "publications. Every listing is in listings.csv with its URL and SKU."),
        table([header] + body, [40 * mm, 22 * mm, 20 * mm, 30 * mm, 22 * mm, 26 * mm],
              align_right=(2, 3)),
        para("What each vendor claims, in its own words", "h2"),
        para(
            "Usable ratio computed from each listing's own stated capacity against its own "
            "external dimensions — what the vendor claims, not what this reference concluded:"),
        table([["Family", "Listings", "Min", "Median", "Max"]] + stat_rows,
              [58 * mm, 20 * mm, 20 * mm, 24 * mm, 20 * mm], align_right=(1, 2, 3, 4)),
        para(
            "The gap between the tapered and straight-walled medians is the single most "
            "important number in this document, and it holds across independent markets. The "
            "euro maximum is inflated by vendors who compute litres geometrically from the "
            "top opening rather than measuring a fill.", "note"),
    ]


def names_page(containers):
    seen = {}
    for r in containers:
        seen.setdefault(r["type"], r["common_names"])
    rows = [[para(f'<b>{FAMILY_TITLES[k]}</b>', "cell"),
             para(seen[k].replace("; ", " · "), "cell")]
            for k in FAMILY_ORDER if k in seen]
    return [
        NextPageTemplate("body"), PageBreak(),
        para("What these boxes are called", "h1"),
        para(
            "Search terms, ordered from the most standard to the most colloquial, including "
            "regional trade names and one genericised vendor name. They are for finding a "
            "product, never for classifying one."),
        table([["Family", "Also called"]] + rows, [42 * mm, 128 * mm]),
        para("Two that mislead", "h2"),
        table([
            ["Term", "The trap"],
            [para("<b>“KLT box”</b>", "cell"),
             para("Applied by vendors to ordinary open-top euroboxes — 14 listings in these "
                  "captures do it, at eight heights and on three footprints, none of them on "
                  "the VDA 4500 grid of 147.5 / 213 / 280 mm. A real KLT is a thicker-walled "
                  "returnable carrier on that grid.", "cell")],
            [para("<b>“Tote”</b>", "cell"),
             para("In US usage any industrial container, tapered or straight, lidded or open. "
                  "In UK usage it leans towards the attached-lid product. “Industrial tote” "
                  "therefore applies to two different families and discriminates nothing.", "cell")],
        ], [30 * mm, 140 * mm]),
        para("Telling them apart without the names", "h2"),
        table([
            ["", "Euro stacking container", "Attached-lid container", "VDA KLT"],
            ["Walls", "straight", "sloping", "straight"],
            ["Lid", "separate purchase", "integral, hinged", "separate"],
            ["Nests when empty", "no", "~75 % of its height", "no"],
            ["Height grid", "manufacturer's choice", "manufacturer's choice", "147.5 / 213 / 280 mm"],
            ["Typical usable ratio", "76–78 %", "73–75 %", "~71 %"],
        ], [34 * mm, 46 * mm, 46 * mm, 44 * mm]),
        Spacer(1, 8 * mm),
        para(
            f"Full dataset, per-listing evidence and the notes behind every figure: "
            f"<link href='{DATASET_URL}' color='#26323d'><u>{DATASET_URL}</u></link>", "note"),
    ]


def main():
    containers = load("containers.csv")
    listings = load("listings.csv")
    index = container_stats.internal_index(listings)
    counts = container_stats.vendor_listing_counts(listings)
    verified = max(r["captured_date"] for r in listings)

    story = cover(containers, listings, verified)
    story += how_to_read()
    for kind in FAMILY_ORDER:
        story += family_section(kind, containers, index, counts)
    story += sources_page(listings)
    story += names_page(containers)

    OUT.parent.mkdir(exist_ok=True)
    build_doc().build(story)
    print(f"{OUT.relative_to(HERE)} — {len(containers)} sizes, {len(listings)} listings")


if __name__ == "__main__":
    main()