enginehall 2.0.0__py3-none-any.whl

pcba/parsers/ioc/validate.py

@@ -0,0 +1,192 @@
+"""Validate an `.ioc` against a manifest of things a regeneration must not silently change.
+
+CubeMX rewrites the whole file on every code-gen. A stray GUI click, a pack update, or a
+merge can move a pin, drop a label, or retune the clock tree, and the diff is 900 lines of
+churn in which nobody spots it. The manifest pins down what matters.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+from pcba.parsers.ioc.reader import IocError, collect_pins, peripherals
+
+# Every section the manifest may contain. A typo'd section name used to disable its check
+# silently and still report "validation passed" — a validator that lies is worse than no
+# validator, because it is trusted.
+#
+# Keys starting with `_` are comments. JSON has no comment syntax and manifests are
+# hand-written, so the convention is worth supporting explicitly. It does not weaken the
+# guard: a misspelled real section (`gpio_label`) has no underscore and is still caught.
+KNOWN_SECTIONS = frozenset({"expect", "peripherals", "gpio_labels", "can"})
+KNOWN_CAN_KEYS = frozenset({"instance", "bitrate_bps", "sample_point_pct", "kernel_clock_hz"})
+
+
+def _sections(manifest: dict[str, Any]) -> set[str]:
+    return {k for k in manifest if not k.startswith("_")}
+
+
+def check_can_timing(values: dict[str, str], spec: dict[str, Any]) -> list[str]:
+    """Verify the CAN bit timing the `.ioc` actually encodes.
+
+        bitrate      = f_kernel / (prescaler * (1 + seg1 + seg2))
+        sample point = (1 + seg1) / (1 + seg1 + seg2)
+
+    Trap: **the `.ioc` does not store the prescaler.** CubeMX writes only the segments plus
+    its own computed `CalculateBaudRateNominal` and `CalculateTimeQuantumNominal` (in ns);
+    the prescaler first appears in the generated `fdcan.c`. So recover it from the time
+    quantum:
+
+        prescaler = f_kernel * tq_ns / 1e9
+
+    and cross-check the result against CubeMX's own stored bitrate. A mismatch means the
+    `.ioc` is internally inconsistent — usually a hand-edit.
+    """
+    errors: list[str] = []
+    instance = str(spec.get("instance", "FDCAN1"))
+    family = "FDCAN" if instance.startswith("FDCAN") else instance.rstrip("0123456789")
+
+    clock_raw = spec.get("kernel_clock_hz") or values.get(f"RCC.{family}Freq_Value")
+    try:
+        clock = int(str(clock_raw))
+        seg1 = int(values[f"{instance}.NominalTimeSeg1"])
+        seg2 = int(values[f"{instance}.NominalTimeSeg2"])
+    except (KeyError, TypeError, ValueError):
+        return [f"{instance}: kernel clock or time segments missing from the .ioc"]
+
+    quanta = 1 + seg1 + seg2
+    if quanta <= 1:
+        return [f"{instance}: nonsensical segments (seg1={seg1}, seg2={seg2})"]
+
+    # Sample point needs no prescaler at all — always checkable.
+    sample = 100.0 * (1 + seg1) / quanta
+
+    prescaler: int | None = None
+    try:
+        if f"{instance}.NominalPrescaler" in values:
+            prescaler = int(values[f"{instance}.NominalPrescaler"])
+        elif f"{instance}.CalculateTimeQuantumNominal" in values:
+            quantum_ns = float(values[f"{instance}.CalculateTimeQuantumNominal"])
+            prescaler = round(clock * quantum_ns / 1e9)
+    except ValueError:
+        return [f"{instance}: prescaler or time quantum is not numeric"]
+
+    stored = values.get(f"{instance}.CalculateBaudRateNominal")
+    stored_bitrate: float | None = None
+    if stored:
+        try:
+            stored_bitrate = float(stored)
+        except ValueError:
+            errors.append(f"{instance}: CalculateBaudRateNominal is not numeric: {stored!r}")
+    bitrate: float | None = None
+    if prescaler and prescaler > 0:
+        bitrate = clock / (prescaler * quanta)
+        if stored_bitrate is not None and abs(bitrate - stored_bitrate) > 1.0:
+            errors.append(
+                f"{instance}: .ioc is inconsistent — segments and time quantum give "
+                f"{bitrate:g} bit/s but CalculateBaudRateNominal says {stored}"
+            )
+    elif stored_bitrate is not None:
+        bitrate = stored_bitrate
+
+    wanted_bitrate = spec.get("bitrate_bps")
+    if wanted_bitrate is not None:
+        if bitrate is None:
+            errors.append(f"{instance}: cannot determine bitrate from the .ioc")
+        elif abs(bitrate - float(str(wanted_bitrate))) > 1.0:
+            errors.append(f"{instance}: bitrate is {bitrate:g} bit/s, expected {wanted_bitrate}")
+
+    wanted_sample = spec.get("sample_point_pct")
+    if wanted_sample is not None and abs(sample - float(str(wanted_sample))) > 0.1:
+        errors.append(f"{instance}: sample point is {sample:.1f} %, expected {wanted_sample}")
+    return errors
+
+
+def load_manifest(path: Path) -> dict[str, Any]:
+    try:
+        manifest = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise IocError(f"cannot read manifest {path}: {exc}") from exc
+    if not isinstance(manifest, dict):
+        raise IocError(f"{path}: manifest must be a JSON object")
+
+    unknown = _sections(manifest) - KNOWN_SECTIONS
+    if unknown:
+        raise IocError(
+            f"{path}: unknown section(s) {', '.join(sorted(unknown))}. "
+            f"Known: {', '.join(sorted(KNOWN_SECTIONS))} (keys starting with '_' are comments). "
+            "Refusing to run — an ignored typo would report a pass having checked nothing."
+        )
+
+    expected_types = {
+        "expect": dict,
+        "peripherals": list,
+        "gpio_labels": dict,
+        "can": dict,
+    }
+    for section, expected_type in expected_types.items():
+        if section in manifest and not isinstance(manifest[section], expected_type):
+            raise IocError(f"{path}: section '{section}' must be a JSON {expected_type.__name__}")
+
+    if "peripherals" in manifest and not all(
+        isinstance(name, str) for name in manifest["peripherals"]
+    ):
+        raise IocError(f"{path}: section 'peripherals' must contain only strings")
+
+    if "can" in manifest:
+        unknown_can = {k for k in manifest["can"] if not k.startswith("_")} - KNOWN_CAN_KEYS
+        if unknown_can:
+            raise IocError(f"{path}: unknown key(s) in 'can': {', '.join(sorted(unknown_can))}")
+        instance = manifest["can"].get("instance")
+        if instance is not None and not isinstance(instance, str):
+            raise IocError(f"{path}: 'can.instance' must be a string")
+        for key in ("bitrate_bps", "sample_point_pct", "kernel_clock_hz"):
+            if key not in manifest["can"]:
+                continue
+            try:
+                value = float(str(manifest["can"][key]))
+            except ValueError as exc:
+                raise IocError(f"{path}: 'can.{key}' must be numeric") from exc
+            if not math.isfinite(value):
+                raise IocError(f"{path}: 'can.{key}' must be finite")
+    return manifest
+
+
+def validate(values: dict[str, str], manifest: dict[str, Any]) -> list[str]:
+    """Return a list of human-readable errors. Empty list means the `.ioc` matches."""
+    errors: list[str] = []
+
+    for key, expected in dict(manifest.get("expect", {})).items():
+        actual = values.get(key)
+        if actual != str(expected):
+            errors.append(f"{key}: expected {expected!r}, found {actual!r}")
+
+    enabled = set(peripherals(values))
+    for name in list(manifest.get("peripherals", [])):
+        if name not in enabled:
+            errors.append(f"peripheral {name} is not enabled")
+
+    actual_labels = {
+        pin: fields["GPIO_Label"]
+        for pin, fields in collect_pins(values).items()
+        if "GPIO_Label" in fields
+    }
+    for pin, label in dict(manifest.get("gpio_labels", {})).items():
+        if actual_labels.get(pin) != label:
+            errors.append(f"{pin}: expected label {label!r}, found {actual_labels.get(pin)!r}")
+
+    # Two pins sharing a label is always a bug, manifest or not. This used to be nested
+    # inside `if gpio_labels:`, so a project that declared no labels silently lost the
+    # check — exactly the project most likely to have a duplicate.
+    seen: dict[str, str] = {}
+    for pin, label in sorted(actual_labels.items()):
+        if label in seen:
+            errors.append(f"duplicate label {label!r} on {seen[label]} and {pin}")
+        seen[label] = pin
+
+    if "can" in manifest:
+        errors.extend(check_can_timing(values, dict(manifest["can"])))
+    return errors

pcba/parsers/kicad/__init__.py

@@ -0,0 +1,103 @@
+"""KiCad project reading: schematic hierarchy, board, and KiCad's own checks.
+
+Read-only and stdlib only. `pcbnew` is never imported: it exists only inside KiCad's bundled
+Python, and a review must run in CI. `kicad-cli` and `ngspice` are optional external tools; when
+they are missing, the checks that need them are reported as not checked.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pcba import components as component_data
+from pcba import requirements as project_requirements
+from pcba import simulation
+from pcba.model.design import Design
+from pcba.parsers.kicad import board as board_reader
+from pcba.parsers.kicad import kicad_cli
+from pcba.parsers.kicad import schematic as schematic_reader
+from pcba.parsers.kicad.pinmap import detect_part, detect_parts, extract
+from pcba.parsers.kicad.schematic import KicadError, find_root
+from pcba.parsers.kicad.sexpr import SexprError
+
+
+def board_file(project_file: Path | None, root_schematic: Path | None) -> Path | None:
+    for anchor in (project_file, root_schematic):
+        if anchor is not None and anchor.with_suffix(".kicad_pcb").is_file():
+            return anchor.with_suffix(".kicad_pcb")
+    folder = (project_file or root_schematic).parent if (project_file or root_schematic) else None
+    boards = sorted(folder.glob("*.kicad_pcb")) if folder else []
+    return boards[0] if len(boards) == 1 else None
+
+
+def load_design(project: Path, review_root: Path, *, tools: bool = True) -> Design:
+    """Read the KiCad project at `project` (a .kicad_pro, root .kicad_sch, .kicad_pcb or folder).
+
+    Unreadable parts become notes, not exceptions: a board without a readable schematic still
+    gets its board checks. A malformed requirements or component file is an error, because the
+    review would otherwise check against promises it silently ignored.
+    """
+    project = Path(project)
+    folder = project if project.is_dir() else project.parent
+    design = Design(root=str(folder.resolve()))
+    if project.suffix == ".kicad_pcb":
+        project_file, root_sch = find_root(folder)
+        board_path: Path | None = project
+    elif project.suffix in (".kicad_pro", ".kicad_sch"):
+        project_file = project.with_suffix(".kicad_pro") if project.with_suffix(".kicad_pro").is_file() else None
+        root_sch = project.with_suffix(".kicad_sch") if project.with_suffix(".kicad_sch").is_file() else None
+        board_path = board_file(project_file, root_sch)
+    else:
+        project_file, root_sch = find_root(folder)
+        board_path = board_file(project_file, root_sch)
+    design.project_file = str(project_file.resolve()) if project_file else None
+
+    if root_sch is not None:
+        try:
+            design.schematic = schematic_reader.read(project_file or root_sch)
+            design.notes += design.schematic.notes
+        except KicadError as exc:
+            design.notes.append(f"cannot read the KiCad schematic: {exc}")
+    else:
+        design.notes.append("no KiCad schematic found; schematic rules will not run")
+    if board_path is not None:
+        try:
+            design.board = board_reader.read(board_path)
+        except KicadError as exc:
+            design.notes.append(f"cannot read the KiCad board: {exc}")
+    else:
+        design.notes.append("no .kicad_pcb found; board rules will not run")
+
+    path = project_requirements.find(review_root, folder)
+    design.requirements = project_requirements.load(path)
+    design.components = component_data.load(design.requirements.databases, design.requirements.assign)
+
+    if tools:
+        design.external.update(kicad_cli.run_all(
+            Path(design.schematic.root_file) if design.schematic else None,
+            Path(design.board.path) if design.board else None,
+        ))
+        base = path.parent if path else folder
+        design.external["spice"] = simulation.run_all(design.requirements.simulations, base, Path(review_root))
+    else:
+        # `enginehall inspect`: say what a review would run, without running it.
+        cli, how = kicad_cli.find()
+        for name, needs in (("erc", design.schematic), ("netlist", design.schematic), ("drc", design.board)):
+            design.external[name] = {"ran": False, "planned": bool(cli and needs),
+                                     "reason": how if cli is None else "not run by inspect"}
+        spice, how = simulation.find()
+        design.external["spice"] = {"ran": False, "planned": bool(spice and design.requirements.simulations),
+                                    "reason": how if spice is None else "not run by inspect"}
+    return design
+
+
+__all__ = [
+    "KicadError",
+    "SexprError",
+    "board_file",
+    "detect_part",
+    "detect_parts",
+    "extract",
+    "find_root",
+    "load_design",
+]

pcba/parsers/kicad/board.py

@@ -0,0 +1,269 @@
+"""Read a `.kicad_pcb` board: footprints, pads, tracks, vias, zones, outline, texts, 3D models.
+
+Two net forms exist and both are read:
+
+- KiCad 9 and older keep a numbered table at the top (`(net 7 "GND")`) and name nets on pads,
+  tracks and vias by number (`(net 7)`); zones add `(net_name "GND")`.
+- KiCad 10 has no table: every item names its net directly (`(net "GND")`).
+
+Pad and footprint-graphic coordinates in the file are relative to their footprint, in the
+footprint's unrotated frame; tracks, vias, zones and board graphics are absolute. A footprint at
+angle a (degrees, counter-clockwise as seen on screen, y down) puts a relative point (x, y) at
+(X + x cos a + y sin a, Y - x sin a + y cos a). A footprint on the back side is stored already
+flipped, so the same transform applies.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from pathlib import Path
+
+from pcba.model.design import Board, Footprint, Graphic, Pad, Track, Via
+from pcba.parsers.kicad.schematic import KicadError
+from pcba.parsers.kicad.sexpr import Node, SexprError, load
+
+Point = tuple[float, float]
+_SEGMENTS_PER_CIRCLE = 32
+
+
+def transform(x: float, y: float, fx: float, fy: float, angle: float) -> Point:
+    """Absolute board position of a footprint-relative point (see the module docstring)."""
+    rad = math.radians(angle)
+    cos, sin = math.cos(rad), math.sin(rad)
+    return (round(fx + x * cos + y * sin, 6), round(fy - x * sin + y * cos, 6))
+
+
+def _xy(node: Node | None) -> Point | None:
+    if node is None:
+        return None
+    atoms = node.atoms()
+    return (float(atoms[0]), float(atoms[1])) if len(atoms) >= 2 else None
+
+
+def _arc_points(start: Point, mid: Point, end: Point) -> list[Point]:
+    """A three-point arc as a polyline (the chord when the points are collinear)."""
+    (x1, y1), (x2, y2), (x3, y3) = start, mid, end
+    d = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2))
+    if abs(d) < 1e-12:
+        return [start, end]
+    ux = ((x1 * x1 + y1 * y1) * (y2 - y3) + (x2 * x2 + y2 * y2) * (y3 - y1) + (x3 * x3 + y3 * y3) * (y1 - y2)) / d
+    uy = ((x1 * x1 + y1 * y1) * (x3 - x2) + (x2 * x2 + y2 * y2) * (x1 - x3) + (x3 * x3 + y3 * y3) * (x2 - x1)) / d
+    r = math.hypot(x1 - ux, y1 - uy)
+    a1, a2, a3 = (math.atan2(y - uy, x - ux) for x, y in (start, mid, end))
+
+    def ccw(a: float, b: float) -> float:
+        return (b - a) % (2 * math.pi)
+
+    sweep = ccw(a1, a3)
+    if ccw(a1, a2) > sweep:   # the mid point is on the other way round
+        sweep -= 2 * math.pi
+    steps = max(2, int(abs(sweep) / (2 * math.pi) * _SEGMENTS_PER_CIRCLE) + 1)
+    return [(ux + r * math.cos(a1 + sweep * i / steps), uy + r * math.sin(a1 + sweep * i / steps))
+            for i in range(steps + 1)]
+
+
+def _circle_points(center: Point, edge: Point) -> list[Point]:
+    r = math.hypot(edge[0] - center[0], edge[1] - center[1])
+    return [(center[0] + r * math.cos(2 * math.pi * i / _SEGMENTS_PER_CIRCLE),
+             center[1] + r * math.sin(2 * math.pi * i / _SEGMENTS_PER_CIRCLE)) for i in range(_SEGMENTS_PER_CIRCLE)]
+
+
+def _shape_points(node: Node) -> tuple[str, list[Point]] | None:
+    """(kind, points) of a gr_*/fp_* graphic in its own frame, or None if it is not a shape."""
+    kind = node.head.split("_", 1)[-1]
+    if kind == "line":
+        a, b = _xy(node.child("start")), _xy(node.child("end"))
+        return ("line", [a, b]) if a and b else None
+    if kind == "arc":
+        a, m, b = _xy(node.child("start")), _xy(node.child("mid")), _xy(node.child("end"))
+        return ("arc", _arc_points(a, m, b)) if a and m and b else None
+    if kind == "circle":
+        c, e = _xy(node.child("center")), _xy(node.child("end"))
+        return ("circle", _circle_points(c, e)) if c and e else None
+    if kind == "rect":
+        a, b = _xy(node.child("start")), _xy(node.child("end"))
+        if not (a and b):
+            return None
+        return "rect", [a, (b[0], a[1]), b, (a[0], b[1])]
+    if kind == "poly":
+        pts = node.child("pts")
+        points = [_xy(xy) for xy in pts.children("xy")] if pts is not None else []
+        return ("poly", [p for p in points if p]) if points else None
+    return None
+
+
+def _text_hidden(node: Node) -> bool:
+    if node.flag("hide"):
+        return True
+    effects = node.child("effects")
+    return bool(effects is not None and effects.flag("hide"))
+
+
+def _text_size(node: Node) -> float:
+    effects = node.child("effects")
+    font = effects.child("font") if effects is not None else None
+    size = font.child("size") if font is not None else None
+    atoms = size.atoms() if size is not None else []
+    return float(atoms[0]) if atoms else 1.0
+
+
+class _Nets:
+    """Resolves `(net ...)` on an item, in either file form."""
+
+    def __init__(self, root: Node) -> None:
+        self.table: dict[str, str] = {}
+        for net in root.children("net"):
+            atoms = net.atoms()
+            if len(atoms) >= 2:
+                self.table[atoms[0]] = atoms[1]
+        self.numbered = bool(self.table)
+
+    def of(self, item: Node) -> str | None:
+        net = item.child("net")
+        if net is None:
+            name = item.value("net_name")
+            return name or None
+        atoms = net.atoms()
+        if not atoms:
+            return None
+        if len(atoms) >= 2:
+            return atoms[1] or None
+        if self.numbered and re.fullmatch(r"\d+", atoms[0]):
+            return self.table.get(atoms[0]) or item.value("net_name") or None
+        return atoms[0] or None
+
+
+def read(path: Path | str) -> Board:
+    path = Path(path)
+    try:
+        root = load(path)
+    except (OSError, SexprError) as exc:
+        raise KicadError(f"cannot read {path.name}: {exc}") from exc
+    if root.head != "kicad_pcb":
+        raise KicadError(f"{path.name} is not a KiCad board")
+    version = int(float(root.value("version", "0") or 0))
+    nets = _Nets(root)
+    default_mask = 0.0
+    setup = root.child("setup")
+    if setup is not None:
+        default_mask = setup.number("pad_to_mask_clearance", 0.0) or 0.0
+    board = Board(path=str(path.resolve()), version=version)
+    board.nets = {name for name in nets.table.values() if name}
+
+    for fp in root.children("footprint"):
+        board.footprints.append(_footprint(fp, nets, default_mask))
+    for item in root.children("segment"):
+        a, b = _xy(item.child("start")), _xy(item.child("end"))
+        if a and b:
+            board.tracks.append(Track(a, b, item.number("width", 0.0) or 0.0, item.value("layer", "") or "",
+                                      nets.of(item), line=item.line))
+    for item in root.children("arc"):
+        a, b = _xy(item.child("start")), _xy(item.child("end"))
+        if a and b:
+            board.tracks.append(Track(a, b, item.number("width", 0.0) or 0.0, item.value("layer", "") or "",
+                                      nets.of(item), arc=True, line=item.line))
+    for item in root.children("via"):
+        at = item.xy("at")
+        if at:
+            layers = item.child("layers")
+            board.vias.append(Via(at[0], at[1], item.number("size", 0.0) or 0.0, item.number("drill", 0.0) or 0.0,
+                                  tuple(layers.atoms()) if layers is not None else (), nets.of(item), line=item.line))
+    for item in root.children("zone"):
+        polygon = item.child("polygon")
+        pts = polygon.child("pts") if polygon is not None else None
+        layers = item.child("layers")
+        board.zones.append({
+            "net": nets.of(item),
+            "layers": (tuple(layers.atoms()) if layers is not None
+                       else ((item.value("layer"),) if item.value("layer") else ())),
+            "keepout": item.child("keepout") is not None,
+            "polygon": [p for p in (_xy(xy) for xy in pts.children("xy")) if p] if pts is not None else [],
+            "line": item.line,
+        })
+    for item in root:
+        if not isinstance(item, Node) or not item.head.startswith("gr_"):
+            continue
+        layer = item.value("layer", "") or ""
+        if item.head == "gr_text":
+            at = item.xy("at") or (0.0, 0.0, 0.0)
+            board.graphics.append(Graphic(layer, "text", ((at[0], at[1]),), text=item[1] if len(item) > 1 else "",
+                                          size=_text_size(item), hidden=_text_hidden(item), line=item.line))
+            continue
+        shape = _shape_points(item)
+        if shape:
+            board.graphics.append(Graphic(layer, shape[0], tuple(shape[1]), line=item.line))
+    for fp in board.footprints:
+        for pad in fp.pads:
+            if pad.net:
+                board.nets.add(pad.net)
+    board.nets |= {t.net for t in board.tracks if t.net} | {v.net for v in board.vias if v.net}
+    return board
+
+
+def _footprint(fp: Node, nets: _Nets, default_mask: float) -> Footprint:
+    at = fp.xy("at") or (0.0, 0.0, 0.0)
+    fx, fy, angle = at
+    properties: dict[str, str] = {}
+    graphics: list[Graphic] = []
+    for prop in fp.children("property"):
+        atoms = prop.atoms()
+        if len(atoms) >= 2:
+            properties[atoms[0]] = atoms[1]
+    for text in fp.children("fp_text"):
+        atoms = text.atoms()
+        if len(atoms) >= 2 and atoms[0] in ("reference", "value"):
+            properties.setdefault(atoms[0].capitalize(), atoms[1])
+    ref = properties.get("Reference", "")
+    fp_mask = fp.number("solder_mask_margin")
+    footprint = Footprint(
+        ref=ref, value=properties.get("Value", ""), lib=fp[1] if len(fp) > 1 and isinstance(fp[1], str) else "",
+        layer=fp.value("layer", "F.Cu") or "F.Cu", x=fx, y=fy, rotation=angle,
+        attributes=tuple(fp.child("attr").atoms()) if fp.child("attr") is not None else (),
+        properties=properties, line=fp.line,
+    )
+    for text in list(fp.children("property")) + list(fp.children("fp_text")):
+        layer = text.value("layer")
+        position = text.xy("at")
+        if not layer or position is None:
+            continue
+        atoms = text.atoms()
+        content = atoms[1] if len(atoms) >= 2 else ""
+        graphics.append(Graphic(layer, "text", (transform(position[0], position[1], fx, fy, angle),), text=content,
+                                size=_text_size(text), hidden=_text_hidden(text), ref=ref, line=text.line))
+    for item in fp:
+        if not isinstance(item, Node) or not item.head.startswith("fp_") or item.head == "fp_text":
+            continue
+        shape = _shape_points(item)
+        if shape:
+            points = tuple(transform(x, y, fx, fy, angle) for x, y in shape[1])
+            graphics.append(Graphic(item.value("layer", "") or "", shape[0], points, ref=ref, line=item.line))
+    footprint.graphics = graphics
+    for pad in fp.children("pad"):
+        atoms = pad.atoms()
+        position = pad.xy("at") or (0.0, 0.0, 0.0)
+        size = pad.child("size")
+        dims = [float(a) for a in size.atoms()[:2]] if size is not None else [0.0, 0.0]
+        while len(dims) < 2:
+            dims.append(dims[0] if dims else 0.0)
+        drill_node = pad.child("drill")
+        drill = 0.0
+        if drill_node is not None:
+            numbers = [a for a in drill_node.atoms() if re.fullmatch(r"-?[\d.]+", a)]
+            drill = float(numbers[0]) if numbers else 0.0
+        layers = pad.child("layers")
+        pad_mask = pad.number("solder_mask_margin")
+        x, y = transform(position[0], position[1], fx, fy, angle)
+        footprint.pads.append(Pad(
+            ref=ref, number=atoms[0] if atoms else "", kind=atoms[1] if len(atoms) > 1 else "",
+            shape=atoms[2] if len(atoms) > 2 else "", x=x, y=y, w=dims[0], h=dims[1],
+            rotation=position[2], layers=tuple(layers.atoms()) if layers is not None else (),
+            net=nets.of(pad), drill=drill,
+            mask_margin=pad_mask if pad_mask is not None else (fp_mask if fp_mask is not None else default_mask),
+            line=pad.line,
+        ))
+    for model in fp.children("model"):
+        atoms = model.atoms()
+        if atoms and not model.flag("hide"):
+            footprint.models.append(atoms[0])
+    return footprint