#!/usr/bin/env python3 """Generate the storage-container-dimensions dataset. Single source of truth for containers.csv and containers.jsonl. Every derived number is computed here rather than typed, so the internal-dimension rule and the capacity that follows from it can never drift apart. Run: python3 build.py """ import csv import json import re import subprocess import sys from pathlib import Path HERE = Path(__file__).parent sys.path.insert(0, str(HERE)) import container_stats # noqa: E402 (needs HERE on the path) import dictionary # noqa: E402 # --------------------------------------------------------------------------- # Internal-dimension rules. # # The standards (ISO 3394, EN 13199, VDA 4500) fix the *external* footprint and, # for VDA, the external height. None of them specifies internal dimensions — wall # thickness, draft angle and rib design are the manufacturer's choice. These rules # are therefore an average across vendor catalogues, accurate to about ±1 L on a # 60x40 box, and are meant for planning rather than for anything load-bearing. # # Format: (internal_L_mm, internal_W_mm, height_deduction_mm) STRAIGHT_WALL_RULES = { (600, 400): (550, 355, 15), (400, 300): (350, 250, 10), (300, 200): (260, 160, 10), (800, 600): (750, 550, 20), } # VDA KLTs are noticeably thicker-walled than consumer euroboxes. Anchored on the # one published pair: R-KLT 6429, 600x400x280 external = 67.2 L, 48 L internal. VDA_USABLE_RATIO = 48 / 67.2 MM_PER_IN = 25.4 L_PER_US_GAL = 3.785411784 def inches(mm): return round(mm / MM_PER_IN, 2) def gallons(litres): return round(litres / L_PER_US_GAL, 1) # Search terms, not a taxonomy. Ordered from the most standard to the most # colloquial, and deliberately including the loose and the regional: someone # searching "Hudson box" or "industrial tote" should land on the right family. # Which terms are evidenced by the captured listings and which are ordinary trade # usage is set out in guidance/naming.md. NAMES = { "euro_stacking_container": ( "Eurobox; Euro container; Eurocontainer; Euro stacking container; euro crate; " "stacking crate; stacking tote; straight-wall tote; industrial tote; " "KLT box (loose vendor usage); KLC; Eurobehälter (DE); Eurokiste (DE); " "Stapelbehälter (DE); bac gerbable (FR); bac Euronorme (FR); " "caja apilable (ES); stapelbak (NL)"), "attached_lid_container": ( "Attached lid container; ALC; attached top container; ATC; attached-lid tote; " "hinged-lid crate; crocodile-lid box (UK); Hudson box (US, after Hudson " "Exchange); distribution tote; industrial tote; Klappdeckelbehälter (DE); " "Deckelbehälter (DE); bac à couvercle solidaire (FR)"), "vda_klt_container": ( "KLT; R-KLT; RL-KLT; Kleinladungsträger (DE); VDA container; VDA 4500 carrier; " "small load carrier; SLC; automotive tote; returnable tote; ESD KLT (conductive)"), } TYPE_LABELS = { "euro_stacking_container": "Euro stacking container (open top)", "attached_lid_container": "Attached-lid container (ALC)", "vda_klt_container": "VDA 4500 KLT (returnable small load carrier)", } # Footprints that are ISO 3394 packaging modules (they divide the 1200x800 Euro # pallet exactly) and are within the EN 13199 small-load-carrier cap of 600x400. ISO_MODULES = {(600, 400), (400, 300), (300, 200)} EUR1_PER_LAYER = {(600, 400): 4, (400, 300): 8, (300, 200): 16, (800, 600): 2} VDA_HEIGHTS_MM = {147.5, 213, 280} # Build the listings table first, so each typical row can record how many real # listings sit behind it. Single entry point: `python3 build.py` does everything. if (HERE / "build_listings.py").exists(): subprocess.run([sys.executable, str(HERE / "build_listings.py")], check=True) LISTINGS = container_stats.load_listings(HERE / "listings.csv") def load_listing_index(): """(type, L_mm, W_mm) -> list of observed heights in mm.""" idx = {} for r in LISTINGS: key = container_stats.footprint(r) if key: idx.setdefault(key, []).append(float(r["external_height_cm"]) * 10) return idx LISTING_INDEX = load_listing_index() INTERNAL_INDEX = container_stats.internal_index(LISTINGS) def internal_dims_vendors(kind, L, W): """How many vendors publish internal dimensions for this footprint. Vendors, not listings: Salesbridges lists the same 600x400 mould in five colours, and five colours are not five opinions. """ return len(INTERNAL_INDEX.get((kind, L, W), {})) def vendor_capacity_span(kind, L, W, H): return container_stats.capacity_span(INTERNAL_INDEX, kind, L, W, H) def published_internal(kind, L, W, H): """Mean of the internal dimensions vendors publish for this exact size, in mm.""" obs = [] for r in LISTINGS: try: if (r["type"] != kind or not r["internal_length_cm"] or round(float(r["external_length_cm"]) * 10) != L or round(float(r["external_width_cm"]) * 10) != W or abs(float(r["external_height_cm"]) * 10 - H) > HEIGHT_TOLERANCE_MM): continue obs.append(tuple(float(r[f"internal_{d}_cm"]) * 10 for d in ("length", "width", "height"))) except ValueError: continue if not obs: return None return tuple(round(sum(o[i] for o in obs) / len(obs)) for i in range(3)) # Vendors round heights differently for what is the same mould — 31 vs 31.5 cm, # 36.5 vs 36.7. A 6 mm window matches a typical row to its real listings without # swallowing the next size up, the closest of which is 20 mm away. HEIGHT_TOLERANCE_MM = 6 def listings_observed(kind, L, W, H): heights = LISTING_INDEX.get((kind, L, W), []) return sum(1 for h in heights if abs(h - H) <= HEIGHT_TOLERANCE_MM) def standard_for(L, W, vda): """Return (conformant, standard string) for a footprint.""" if vda: return True, "VDA 4500 (R-KLT); ISO 3394 packaging module; EN 13199 small load carrier" if (L, W) in ISO_MODULES: return True, "ISO 3394 packaging module; within the EN 13199 600x400 small-load-carrier cap" if (L, W) == (800, 600): return True, "Euro pallet module (half of 1200x800); exceeds the EN 13199 600x400 small-load-carrier cap" return False, "" def row(kind, L, W, H, capacity_l=None, note="", vda_code=None): """Build one dataset record. Dimensions in mm; output in cm.""" ext_l = L * W * H / 1e6 vda = kind == "vda_klt_container" alc = kind == "attached_lid_container" if alc: # ALC walls taper hard enough that a single internal L x W x H would be # wrong wherever you measured it, and no vendor in listings.csv publishes # one for a 600x400 or 400x300 ALC. Capacity is the vendor's nominal # figure and is the only honest usable number here. int_l = int_w = int_h = None basis = "vendor_nominal" dims_basis = "not_published_tapered_walls" cap = capacity_l elif vda: # KLTs are thicker-walled than consumer euroboxes, so the straight-wall # rule does not transfer. Where a vendor publishes internal dimensions for # the exact size, use theirs; elsewhere leave them empty. pub = published_internal(kind, L, W, H) int_l, int_w, int_h = pub if pub else (None, None, None) dims_basis = "vendor_published" if pub else "not_published" cap = capacity_l if capacity_l is not None else round(ext_l * VDA_USABLE_RATIO, 1) basis = "published" if capacity_l is not None else "derived_from_klt_ratio" else: il, iw, dh = STRAIGHT_WALL_RULES[(L, W)] int_l, int_w, int_h = il, iw, H - dh cap = round(il * iw * (H - dh) / 1e6, 1) basis = "derived_from_internal_dims" dims_basis = "vendor_average_rule" cap_low, cap_high = vendor_capacity_span(kind, L, W, H) conformant, standard = standard_for(L, W, vda) ident = vda_code or f"{'alc' if alc else 'euro'}-{L}x{W}x{H}" return { "id": ident, "type": kind, "type_label": TYPE_LABELS[kind], "common_names": NAMES[kind], # Both unit systems on every row. These nominal sizes are metric by # definition — the standards fix them in millimetres — so the inch columns # are always the derived side here, unlike listings.csv where a US vendor's # own figure is the inch one. They are carried anyway because the reader # comparing a US tote against a Eurobox should not have to convert first. "external_length_cm": L / 10, "external_width_cm": W / 10, "external_height_cm": H / 10, "external_length_in": inches(L), "external_width_in": inches(W), "external_height_in": inches(H), "external_volume_l": round(ext_l, 1), "external_volume_gal": gallons(ext_l), "internal_length_cm": int_l / 10 if int_l else "", "internal_width_cm": int_w / 10 if int_w else "", "internal_height_cm": int_h / 10 if int_h else "", "internal_length_in": inches(int_l) if int_l else "", "internal_width_in": inches(int_w) if int_w else "", "internal_height_in": inches(int_h) if int_h else "", "internal_dims_basis": dims_basis, "internal_dims_vendors": internal_dims_vendors(kind, L, W), "typical_capacity_l": cap, "typical_capacity_gal": gallons(cap), # The same external size quoted by different vendors. Empty where no # vendor in listings.csv publishes internal dimensions for the footprint. "vendor_capacity_low_l": cap_low, "vendor_capacity_high_l": cap_high, "usable_ratio": round(cap / ext_l, 3), "capacity_basis": basis, "lidded": alc, "lid_available_separately": not alc, "nestable_when_empty": alc, # 0.0 rather than blank: a straight-walled box has a nesting ratio of zero, # which is a fact about it, not missing data. Blanks here also made the Hub's # type inference read the whole column as null. "typical_nesting_ratio": 0.75 if alc else 0.0, "standard_conformant": conformant, "standard": standard, "vda_4500_height": H in VDA_HEIGHTS_MM, "eur1_pallet_per_layer": EUR1_PER_LAYER[(L, W)], "listings_observed": listings_observed(kind, L, W, H), "notes": note, } ROWS = [] # --- Euro stacking containers, open top -------------------------------------- # # The height series below is the union of what was actually observed on sale in # the captures under raw/ and the 2026-07-23 Israeli research pass, with # near-duplicates merged to the round figure (315 -> 310, 365/370 -> 365, # 415/420 -> 420). No standard defines these heights — unlike the VDA grid, the # consumer euro series is whatever manufacturers converged on — so "common" here # means "seen for sale", not "specified anywhere". for H in (120, 150, 170, 175, 200, 220, 230, 240, 270, 280, 300, 310, 320, 340, 365, 400, 420, 465): ROWS.append(row("euro_stacking_container", 600, 400, H)) for H in (120, 150, 170, 200, 220, 230, 240, 270, 320): ROWS.append(row("euro_stacking_container", 400, 300, H)) for H in (120, 150, 170, 220): ROWS.append(row("euro_stacking_container", 300, 200, H)) for H in (220, 320, 420): ROWS.append(row( "euro_stacking_container", 800, 600, H, note="800x600 internal rule is not cross-checked against a published internal " "dimension; thin-walled containers of this size are marketed above it", )) # --- Attached-lid containers ------------------------------------------------- ALC_600 = [ (250, 44, ""), (310, 56, "Nominal capacity for this external size varies by range: 56 L " "(Loadhog/Kaiman-compatible), 55 L and 53 L are all sold"), (367, 65, ""), (400, 80, "Outlier: 83 % usable ratio where the rest of the range sits at 73-75 %. " "Published figure, not independently measured — treat with caution"), ] for H, cap, note in ALC_600: ROWS.append(row("attached_lid_container", 600, 400, H, capacity_l=cap, note=note)) for H, cap in ((222, 22), (264, 25), (306, 30)): ROWS.append(row("attached_lid_container", 400, 300, H, capacity_l=cap)) # --- VDA 4500 R-KLT ---------------------------------------------------------- # The only heights the standard actually defines. 6429 is the published anchor. VDA = [ ("vda-rklt-6415", 600, 400, 147.5, None, ""), ("vda-rklt-6422", 600, 400, 213, None, ""), ("vda-rklt-6429", 600, 400, 280, 48.0, "Published: 65 L external / 48 L internal, tare 2.97 kg. Anchors the KLT ratio " "used for the other two heights"), ("vda-rklt-4315", 400, 300, 147.5, None, ""), ("vda-rklt-4322", 400, 300, 213, None, ""), ("vda-rklt-4329", 400, 300, 280, None, ""), ("vda-rklt-3215", 300, 200, 147.5, None, "The 300x200 module exists only in the 147.5 mm height"), ] for code, L, W, H, cap, note in VDA: ROWS.append(row("vda_klt_container", L, W, H, capacity_l=cap, note=note, vda_code=code)) FIELDS = list(ROWS[0].keys()) with (HERE / "containers.csv").open("w", newline="", encoding="utf-8") as f: w = csv.DictWriter(f, fieldnames=FIELDS) w.writeheader() w.writerows(ROWS) with (HERE / "containers.jsonl").open("w", encoding="utf-8") as f: for r in ROWS: clean = {k: (None if v == "" else v) for k, v in r.items()} f.write(json.dumps(clean, ensure_ascii=False) + "\n") # --------------------------------------------------------------------------- # Declare the schema in the dataset card. # # Without this the Hub infers column types from the CSV, and any column that is # mostly blank — `notes` especially — gets inferred as all-null, which breaks # `load_dataset` for anyone reading that field. Writing the frontmatter from the # same run that writes the data is the only way to keep the two in step. DTYPES = dictionary.DTYPES def write_dictionary(): """Render the dictionary as a CSV and a document, and verify it matches.""" dictionary.check("containers", FIELDS) with (HERE / "listings.csv").open(encoding="utf-8") as f: dictionary.check("listings", next(csv.reader(f))) rows = [ {"table": table, "file": fname, "column": name, "dtype": dtype, "unit": unit, "description": desc} for table, (fname, cols) in dictionary.TABLES.items() for name, dtype, unit, desc in cols ] with (HERE / "data-dictionary.csv").open("w", newline="", encoding="utf-8") as f: w = csv.DictWriter(f, fieldnames=list(rows[0])) w.writeheader() w.writerows(rows) doc = [ "# Data dictionary\n\n", f"Version {dictionary.VERSION}. Generated by `build.py` from `dictionary.py` " "— do not hand-edit.\n\n", "Every column in both tables, with its type, unit and meaning. The machine-" "readable form of this file is [`data-dictionary.csv`](../data-dictionary.csv); " "the same definitions render the dataset card's field table and the Hub's " "dtype declarations, so the three cannot disagree.\n", ] for table, (fname, cols) in dictionary.TABLES.items(): doc.append(f"\n## `{table}` → `{fname}`\n") doc.append(f"{len(cols)} columns.\n\n") doc.append("| Column | Type | Unit | Description |\n|---|---|---|---|\n") for name, dtype, unit, desc in cols: doc.append(f"| `{name}` | {dtype} | {unit or '—'} | {desc} |\n") (HERE / "docs").mkdir(exist_ok=True) (HERE / "docs" / "data-dictionary.md").write_text("".join(doc), encoding="utf-8") # The datasheet is a Typst document that reads the CSVs at compile time; the # one thing it cannot get from them is the dictionary's version. (HERE / "datasheet").mkdir(exist_ok=True) (HERE / "datasheet" / "version.json").write_text( json.dumps({"version": dictionary.VERSION}) + "\n", encoding="utf-8") return rows def fields_table(): """The dataset card's Fields section, rendered from the dictionary.""" out = ["| Field | Type | Notes |", "|---|---|---|"] for name, dtype, unit, desc in dictionary.CONTAINERS: u = f" ({unit})" if unit else "" out.append(f"| `{name}` | {dtype}{u} | {desc} |") return "\n".join(out) def features(names, indent=" "): return "\n".join( f"{indent}- name: {n}\n{indent} dtype: {DTYPES.get(n, 'string')}" for n in names ) def config_block(name, csv_name, names, n_rows): return (f" - config_name: {name}\n" f" features:\n{features(names, ' ')}\n" f" splits:\n - name: train\n num_examples: {n_rows}") def frontmatter(): # listings.csv is produced by build_listings.py, run just above. Reading its # header here rather than duplicating the field list keeps the two in step. listings = HERE / "listings.csv" extra_cfg = "" extra_info = "" if listings.exists(): with listings.open(encoding="utf-8") as f: rdr = csv.reader(f) lfields = next(rdr) lrows = sum(1 for _ in rdr) extra_cfg = "\n - config_name: listings\n data_files: listings.csv" extra_info = "\n" + config_block("listings", "listings.csv", lfields, lrows) feats = features(FIELDS) return f"""--- license: cc-by-4.0 language: - en pretty_name: Industrial Storage Container Dimensions size_categories: - n<1K tags: - logistics - supply-chain - warehousing - packaging - reference - tabular configs: - config_name: default data_files: containers.csv{extra_cfg} dataset_info: {config_block("default", "containers.csv", FIELDS, len(ROWS))}{extra_info} ---""" DICT_ROWS = write_dictionary() readme = HERE / "README.md" if readme.exists(): body = readme.read_text(encoding="utf-8") if body.startswith("---"): body = body.split("---", 2)[2].lstrip("\n") # The Fields table is rendered from dictionary.py, so replace whatever is # between the heading and the next one rather than trusting it to be current. body = re.sub( r"(## Fields\n\n).*?(\n### )", lambda m: m.group(1) + fields_table() + "\n" + m.group(2), body, count=1, flags=re.S) readme.write_text(frontmatter() + "\n\n" + body, encoding="utf-8") print(f"{len(ROWS)} rows -> containers.csv, containers.jsonl, README.md frontmatter") print(f"{len(DICT_ROWS)} columns -> data-dictionary.csv, docs/data-dictionary.md") for kind in TYPE_LABELS: n = sum(1 for r in ROWS if r["type"] == kind) print(f" {kind}: {n}")