Printing the Shell

// configs/print_profiles/outer_shell.json
{
  "part": "outer_shell",
  "material": "PLA",
  "layer_height_mm": 0.2,
  "wall_count": 4,
  "infill_percent": 20,
  "nozzle_temp_c": 205,
  "bed_temp_c": 60,
  "fan_percent": 100,
  "hole_clearance_mm": 0.4,
  "overhangs": true,
  "supports_enabled": true,
  "near_heat": false
}

# labs/print_check.py
import json
from pathlib import Path

PROFILES = Path("configs/print_profiles")

def load_profile(path: Path) -> dict:
    return json.loads(path.read_text())

if __name__ == "__main__":
    profile = load_profile(PROFILES / "outer_shell.json")
    for key in ("part", "material", "layer_height_mm", "wall_count", "nozzle_temp_c"):
        print(f"{key:<18}{profile[key]}")

$ uv run python -m labs.print_check
part              outer_shell
material          PLA
layer_height_mm   0.2
wall_count        4
nozzle_temp_c     205

Echoing the fields before validating them sounds like a wasted stage until a key is misspelled. layer_hight_mm surfaces here as a KeyError on line eleven, not three functions deep inside a check that quietly found nothing to complain about. Two fields describe the model instead of a preference: overhangs and near_heat state where the part sits and what its geometry does, and the validator leans on both. One field is measured rather than chosen: hole_clearance_mm is 0.4 because of a coupon printed later in this chapter.

MATERIAL_SPECS = {
    "PLA": {
        "layer_height_mm":   (0.12, 0.28),
        "wall_count":        (3, 6),
        "infill_percent":    (15, 40),
        "nozzle_temp_c":     (195, 220),
        "bed_temp_c":        (50, 65),
        "fan_percent":       (80, 100),
        "hole_clearance_mm": (0.2, 0.5),
    },
    "PETG": {
        "layer_height_mm":   (0.12, 0.28),
        "wall_count":        (3, 6),
        "infill_percent":    (15, 40),
        "nozzle_temp_c":     (230, 250),
        "bed_temp_c":        (70, 90),
        "fan_percent":       (30, 60),
        "hole_clearance_mm": (0.2, 0.5),
    },
}

def check_ranges(profile: dict) -> list[str]:
    material = str(profile.get("material", "")).upper()
    if material not in MATERIAL_SPECS:
        return [f"material {material!r} is not one of {sorted(MATERIAL_SPECS)}"]
    errors: list[str] = []
    for key, (low, high) in MATERIAL_SPECS[material].items():
        value = profile.get(key)
        if value is None:
            errors.append(f"missing setting: {key}")
        elif not low <= value <= high:
            errors.append(f"{key} = {value} outside {material} spec {low}-{high}")
    return errors

if __name__ == "__main__":
    draft = {"material": "pla", "layer_height_mm": 0.32, "wall_count": 4,
             "infill_percent": 20, "nozzle_temp_c": 205, "bed_temp_c": 60,
             "hole_clearance_mm": 0.4}
    for label, profile in (("outer_shell", load_profile(PROFILES / "outer_shell.json")),
                           ("draft copy", draft)):
        print(f"{label + ':':<14}{check_ranges(profile)}")

$ uv run python -m labs.print_check
outer_shell:  []
draft copy:   ['layer_height_mm = 0.32 outside PLA spec 0.12-0.28', 'missing setting: fan_percent']

No branch anywhere in check_ranges knows what PLA is. The material string selects a table of bounds and the loop walks whatever it finds there, so teaching the tool about ABS is one dict entry and no code, and the lowercase pla in the draft still finds its table because .upper() runs before the lookup. The unknown-material case returns early on purpose: with no known material there are no bounds to check against, and six missing-setting lines underneath would bury the one line that matters. Note the None guard before the comparison. A missing key has to become a sentence, and 0.12 <= None raises instead of returning False.

HEAT_SAFE = {"PETG"}
DECLARATIONS = ("overhangs", "near_heat")

def check_flags(profile: dict) -> list[str]:
    errors: list[str] = []
    for key in DECLARATIONS:
        if key not in profile:
            errors.append(f"missing declaration: {key} (true or false, no default)")
    if profile.get("overhangs") is True and profile.get("supports_enabled") is not True:
        errors.append("overhangs: true requires supports_enabled: true, got "
                      f"{profile.get('supports_enabled')!r}")
    if profile.get("near_heat") is True:
        material = str(profile.get("material", "")).upper()
        if material not in HEAT_SAFE:
            errors.append(f"near_heat: true requires {sorted(HEAT_SAFE)}, "
                          f"got {profile.get('material')!r}")
    return errors

def validate(profile: dict) -> list[str]:
    return check_ranges(profile) + check_flags(profile)

Ranges answer whether a number is sane. Flags answer whether you turned on something the geometry demands, and they are conditional: supports are wasted plastic on a flat plate and mandatory under a 60-degree overhang, so the requirement keys off a fact the profile states about the model. The presence loop is the part people leave out. A profile that never says whether the part has overhangs is a profile nobody finished, and reading a missing declaration as false is how an unsupported eye housing prints its ceiling as a hanging mess of strings. Both checks feed one list, so every problem in a file arrives in a single run.

import sys

def main() -> None:
    paths = sorted(PROFILES.glob("*.json"))
    if not paths:
        print(f"no profiles found in {PROFILES}")
        sys.exit(1)
    failed = 0
    for path in paths:
        errors = validate(load_profile(path))
        failed += bool(errors)
        print(f"[{'FAIL' if errors else 'PASS'}] {path.stem:<16}"
              f"{len(errors)} problem(s)")
        for err in errors:
            print(f"         x {err}")
    print(f"\n{len(paths) - failed} of {len(paths)} profiles cleared to slice")
    sys.exit(1 if failed else 0)

if __name__ == "__main__":
    main()

$ uv run python -m labs.print_check ; echo "exit: $?"
[PASS] base_plate      0 problem(s)
[PASS] eye_housing     0 problem(s)
[PASS] outer_shell     0 problem(s)
[FAIL] servo_bracket   2 problem(s)
         x layer_height_mm = 0.3 outside PLA spec 0.12-0.28
         x near_heat: true requires ['PETG'], got 'PLA'

3 of 4 profiles cleared to slice
exit: 1

The bracket profile was copied from the shell and edited halfway, which is how these files actually go wrong: PLA left next to a servo that will warm it, and 0.3 mm layers picked up from a draft profile too coarse for a part with a screw boss. Neither line came from wisdom. Both came from a table with the numbers written down. The exit code is what makes the tool a gate: uv run python -m labs.print_check && ./slice.sh servo_bracket never reaches the slicer while that file is wrong, and a shell that stops on a non-zero exit is the cheapest interlock in the project.

# labs/coupon.py — a 40 x 15 x 4 mm bar with four holes, printed flat
SCREW_MM = 3.0
SLIP_FIT_MM = 0.05

def clearance_report(modeled: list[float], measured: list[float]) -> None:
    for want, got in zip(modeled, measured):
        fit = "slips" if got >= SCREW_MM + SLIP_FIT_MM else "binds"
        print(f"modeled {want:.2f}  measured {got:.2f}  lost {want - got:.2f}  M3 {fit}")

if __name__ == "__main__":
    clearance_report([3.00, 3.20, 3.40, 3.60], [2.78, 2.96, 3.19, 3.38])

$ uv run python -m labs.coupon   # measured on the bench — yours will vary
modeled 3.00  measured 2.78  lost 0.22  M3 binds
modeled 3.20  measured 2.96  lost 0.24  M3 binds
modeled 3.40  measured 3.19  lost 0.21  M3 slips
modeled 3.60  measured 3.38  lost 0.22  M3 slips

Twelve minutes of printing and four caliper readings replace an argument. This printer loses about 0.22 mm across every hole whatever its size, so 3.4 mm is the smallest modeled diameter an M3 passes through freely, and 0.4 goes into every profile as hole_clearance_mm. Print the coupon in PETG and the numbers move, so the field sits per part instead of in a constant at the top of the file. Keep the bar. It is the physical twin of the acceptance log from chapter 42: a measurement with a date on it, taken before the eight-hour print instead of after.