| from __future__ import annotations |
|
|
| import math |
| import os |
| import re |
| import shutil |
| import subprocess |
| import tempfile |
| from pathlib import Path |
|
|
|
|
| DESKTOP = Path("/home/user/Desktop") |
| KICAD_CLI = Path(os.environ.get("KICAD_CLI", "/usr/bin/kicad-cli")) |
| EXPECTED_BOARD_VERSION = "20260206" |
| TOL = 1e-4 |
| TAB_TOL = 0.08 |
|
|
|
|
| class ValidationError(ValueError): |
| pass |
|
|
|
|
| def _parse_sexp(text: str): |
| roots = [] |
| stack = [] |
| index = 0 |
| length = len(text) |
|
|
| def append(value): |
| if stack: |
| stack[-1].append(value) |
| else: |
| roots.append(value) |
|
|
| while index < length: |
| char = text[index] |
| if char.isspace(): |
| index += 1 |
| continue |
| if char == ";": |
| newline = text.find("\n", index) |
| index = length if newline < 0 else newline + 1 |
| continue |
| if char == "(": |
| node = [] |
| append(node) |
| stack.append(node) |
| index += 1 |
| continue |
| if char == ")": |
| if not stack: |
| raise ValidationError("unexpected closing parenthesis") |
| stack.pop() |
| index += 1 |
| continue |
| if char == '"': |
| index += 1 |
| value = [] |
| while index < length: |
| char = text[index] |
| if char == '"': |
| index += 1 |
| break |
| if char == "\\": |
| index += 1 |
| if index >= length: |
| raise ValidationError("unterminated escape") |
| escaped = text[index] |
| value.append({"n": "\n", "r": "\r", "t": "\t"}.get(escaped, escaped)) |
| index += 1 |
| continue |
| value.append(char) |
| index += 1 |
| else: |
| raise ValidationError("unterminated string") |
| append("".join(value)) |
| continue |
|
|
| start = index |
| while index < length and not text[index].isspace() and text[index] not in "();": |
| index += 1 |
| if start == index: |
| raise ValidationError("invalid token") |
| append(text[start:index]) |
|
|
| if stack: |
| raise ValidationError("unterminated list") |
| if len(roots) != 1 or not isinstance(roots[0], list): |
| raise ValidationError("expected one root expression") |
| return roots[0] |
|
|
|
|
| def _head(node): |
| return node[0] if isinstance(node, list) and node else None |
|
|
|
|
| def _direct(node, name: str): |
| return [ |
| child |
| for child in node[1:] |
| if isinstance(child, list) and child and child[0] == name |
| ] |
|
|
|
|
| def _single_node(node, name: str): |
| matches = _direct(node, name) |
| if len(matches) != 1: |
| raise ValidationError(f"expected one {name} node") |
| return matches[0] |
|
|
|
|
| def _single_value(node, name: str): |
| match = _single_node(node, name) |
| if len(match) < 2 or isinstance(match[1], list): |
| raise ValidationError(f"invalid {name} value") |
| return match[1] |
|
|
|
|
| def _numbers(node, name: str, minimum: int = 2): |
| match = _single_node(node, name) |
| raw = [] |
| for item in match[1:]: |
| if isinstance(item, list): |
| break |
| raw.append(item) |
| if len(raw) < minimum: |
| raise ValidationError(f"invalid {name} coordinates") |
| try: |
| return tuple(float(item) for item in raw) |
| except ValueError as exc: |
| raise ValidationError(f"non-numeric {name}") from exc |
|
|
|
|
| def _property(node, name: str): |
| matches = [ |
| child |
| for child in _direct(node, "property") |
| if len(child) >= 3 and child[1] == name and not isinstance(child[2], list) |
| ] |
| if len(matches) != 1: |
| raise ValidationError(f"expected one {name} property") |
| return matches[0][2] |
|
|
|
|
| def _close(left: float, right: float, tolerance: float = TOL) -> bool: |
| return abs(left - right) <= tolerance |
|
|
|
|
| def _point_close(left, right, tolerance: float = TOL) -> bool: |
| return _close(left[0], right[0], tolerance) and _close(left[1], right[1], tolerance) |
|
|
|
|
| def _segment_close(left, right, tolerance: float = TOL) -> bool: |
| return ( |
| _point_close(left[0], right[0], tolerance) |
| and _point_close(left[1], right[1], tolerance) |
| ) or ( |
| _point_close(left[0], right[1], tolerance) |
| and _point_close(left[1], right[0], tolerance) |
| ) |
|
|
|
|
| def _arc_close(left, right, tolerance: float = TOL) -> bool: |
| direct = all(_point_close(a, b, tolerance) for a, b in zip(left, right)) |
| reverse = ( |
| _point_close(left[0], right[2], tolerance) |
| and _point_close(left[1], right[1], tolerance) |
| and _point_close(left[2], right[0], tolerance) |
| ) |
| return direct or reverse |
|
|
|
|
| def _match_exact(actual, expected, comparator, label: str) -> None: |
| if len(actual) != len(expected): |
| raise ValidationError(f"wrong {label} count") |
| unmatched = list(actual) |
| for wanted in expected: |
| for index, observed in enumerate(unmatched): |
| if comparator(observed, wanted): |
| unmatched.pop(index) |
| break |
| else: |
| raise ValidationError(f"missing {label} geometry") |
| if unmatched: |
| raise ValidationError(f"unexpected {label} geometry") |
|
|
|
|
| def _read_board(path: Path): |
| if not path.is_file() or path.stat().st_size < 100: |
| raise ValidationError(f"missing or empty {path.name}") |
| return _parse_sexp(path.read_text(encoding="utf-8")) |
|
|
|
|
| def _check_header(root, expected_title: str) -> None: |
| if _head(root) != "kicad_pcb": |
| raise ValidationError("not a KiCad PCB") |
| if _single_value(root, "version") != EXPECTED_BOARD_VERSION: |
| raise ValidationError("board is not in the KiCad 10.0.2 format") |
| if _single_value(root, "generator") != "pcbnew": |
| raise ValidationError("wrong PCB generator") |
| if _single_value(root, "generator_version") != "10.0": |
| raise ValidationError("wrong PCB generator version") |
| general = _single_node(root, "general") |
| if not _close(float(_single_value(general, "thickness")), 1.6): |
| raise ValidationError("wrong board thickness") |
| title_block = _single_node(root, "title_block") |
| if _single_value(title_block, "title") != expected_title: |
| raise ValidationError("wrong board title") |
|
|
|
|
| def _edge_lines(root): |
| result = [] |
| for node in _direct(root, "gr_line"): |
| if _single_value(node, "layer") != "Edge.Cuts": |
| continue |
| result.append((_numbers(node, "start")[:2], _numbers(node, "end")[:2])) |
| return result |
|
|
|
|
| def _edge_arcs(root): |
| result = [] |
| for node in _direct(root, "gr_arc"): |
| if _single_value(node, "layer") != "Edge.Cuts": |
| continue |
| result.append( |
| ( |
| _numbers(node, "start")[:2], |
| _numbers(node, "mid")[:2], |
| _numbers(node, "end")[:2], |
| ) |
| ) |
| return result |
|
|
|
|
| def _footprint_at(node): |
| values = _numbers(node, "at") |
| return values[0], values[1], values[2] if len(values) >= 3 else 0.0 |
|
|
|
|
| def _pad_at(node): |
| matches = _direct(node, "at") |
| if not matches: |
| return 0.0, 0.0, 0.0 |
| values = [] |
| for item in matches[0][1:]: |
| if isinstance(item, list): |
| break |
| values.append(float(item)) |
| if len(values) < 2: |
| raise ValidationError("invalid pad position") |
| return values[0], values[1], values[2] if len(values) >= 3 else 0.0 |
|
|
|
|
| def _world_pad(footprint, pad): |
| fx, fy, rotation = _footprint_at(footprint) |
| px, py, _ = _pad_at(pad) |
| radians = math.radians(rotation) |
| return ( |
| fx + px * math.cos(radians) - py * math.sin(radians), |
| fy + px * math.sin(radians) + py * math.cos(radians), |
| ) |
|
|
|
|
| def _pad_net(pad): |
| nets = _direct(pad, "net") |
| if len(nets) != 1: |
| raise ValidationError("pad must have exactly one net") |
| scalars = [value for value in nets[0][1:] if not isinstance(value, list)] |
| if not scalars: |
| raise ValidationError("invalid pad net") |
| return scalars[-1] |
|
|
|
|
| def _layers(node): |
| layer_node = _single_node(node, "layers") |
| return {str(value) for value in layer_node[1:] if not isinstance(value, list)} |
|
|
|
|
| def _pad_size(pad): |
| values = _numbers(pad, "size") |
| return values[0], values[1] |
|
|
|
|
| def _pad_drill(pad): |
| values = _numbers(pad, "drill", minimum=1) |
| return values |
|
|
|
|
| def _check_testpoint(footprint, expected_reference: str | None = None): |
| if len(footprint) < 2 or footprint[1] != "TestPoint:TestPoint_Pad_D1.5mm": |
| raise ValidationError("wrong test-point footprint library ID") |
| reference = _property(footprint, "Reference") |
| if expected_reference is not None and reference != expected_reference: |
| raise ValidationError("wrong source reference") |
| if _property(footprint, "Value") != "TP": |
| raise ValidationError("wrong test-point value") |
| pads = _direct(footprint, "pad") |
| if len(pads) != 1: |
| raise ValidationError("test point must have one pad") |
| pad = pads[0] |
| if len(pad) < 4 or pad[1:4] != ["1", "thru_hole", "circle"]: |
| raise ValidationError("wrong test-point pad type") |
| if not _point_close(_pad_at(pad)[:2], (0.0, 0.0)): |
| raise ValidationError("test-point pad moved within footprint") |
| if not _point_close(_pad_size(pad), (1.5, 1.5)): |
| raise ValidationError("wrong test-point pad size") |
| drill = _pad_drill(pad) |
| if len(drill) != 1 or not _close(drill[0], 0.8): |
| raise ValidationError("wrong test-point drill") |
| if _layers(pad) != {"*.Cu", "*.Mask"}: |
| raise ValidationError("wrong test-point pad layers") |
| return reference, _footprint_at(footprint)[:2], _pad_net(pad) |
|
|
|
|
| def _check_source(root): |
| _check_header(root, "PNL02 Board A \u2014 L-shape") |
| footprints = _direct(root, "footprint") |
| if len(footprints) != 2: |
| raise ValidationError("source must contain two footprints") |
| observed = {} |
| for footprint in footprints: |
| reference, position, net = _check_testpoint(footprint) |
| if reference in observed: |
| raise ValidationError("duplicate source reference") |
| observed[reference] = (position, net) |
| expected = { |
| "TP1": ((15.0, 15.0), "VCC"), |
| "TP2": ((15.0, 25.0), "GND"), |
| } |
| if set(observed) != set(expected): |
| raise ValidationError("wrong source references") |
| for reference, (position, net) in expected.items(): |
| actual_position, actual_net = observed[reference] |
| if not _point_close(actual_position, position) or actual_net != net: |
| raise ValidationError("wrong source test-point data") |
|
|
| expected_lines = [ |
| ((0.0, 0.0), (30.0, 0.0)), |
| ((30.0, 0.0), (30.0, 20.0)), |
| ((30.0, 20.0), (20.0, 20.0)), |
| ((20.0, 30.0), (0.0, 30.0)), |
| ((0.0, 3.0), (0.0, 30.0)), |
| ] |
| _match_exact(_edge_lines(root), expected_lines, _segment_close, "source line") |
| source_arcs = _edge_arcs(root) |
| expected_arcs = [ |
| ((0.0, 3.0), (-2.244466, 1.5), (0.0, 0.0)), |
| ((20.0, 30.0), (17.071, 27.071), (20.0, 20.0)), |
| ] |
| _match_exact(source_arcs, expected_arcs, _arc_close, "source arc") |
| return source_arcs |
|
|
|
|
| def _cluster(values, tolerance: float = TOL): |
| groups = [] |
| for value in sorted(values): |
| if not groups or abs(value - groups[-1][-1]) > tolerance: |
| groups.append([value]) |
| else: |
| groups[-1].append(value) |
| return [sum(group) / len(group) for group in groups] |
|
|
|
|
| def _nearest_level(value: float, levels): |
| distances = [abs(value - level) for level in levels] |
| index = min(range(len(levels)), key=distances.__getitem__) |
| if distances[index] > TOL: |
| raise ValidationError("position is off the panel grid") |
| return index |
|
|
|
|
| def _panel_origins(root): |
| footprints = _direct(root, "footprint") |
| testpoints = [ |
| footprint |
| for footprint in footprints |
| if len(footprint) >= 2 and footprint[1] == "TestPoint:TestPoint_Pad_D1.5mm" |
| ] |
| if len(testpoints) != 12: |
| raise ValidationError("panel must contain twelve copied test points") |
|
|
| references = set() |
| vcc = [] |
| gnd = [] |
| for footprint in testpoints: |
| reference, position, net = _check_testpoint(footprint) |
| if not re.fullmatch(r"TP[1-9][0-9]*", reference) or reference in references: |
| raise ValidationError("test-point references must be unique TP references") |
| references.add(reference) |
| if net == "VCC": |
| vcc.append((position[0] - 15.0, position[1] - 15.0)) |
| elif net == "GND": |
| gnd.append((position[0] - 15.0, position[1] - 25.0)) |
| else: |
| raise ValidationError("copied test point has wrong net") |
| if len(vcc) != 6 or len(gnd) != 6: |
| raise ValidationError("each board copy needs VCC and GND test points") |
| _match_exact(gnd, vcc, _point_close, "test-point origin") |
|
|
| x_levels = _cluster([point[0] for point in vcc]) |
| y_levels = _cluster([point[1] for point in vcc]) |
| if len(x_levels) != 3 or len(y_levels) != 2: |
| raise ValidationError("test points do not form a 3x2 grid") |
| for left, right in zip(x_levels, x_levels[1:]): |
| if not 7.0 <= right - left - 30.0 <= 9.0: |
| raise ValidationError("horizontal board spacing is not approximately 8 mm") |
| if not 7.0 <= y_levels[1] - y_levels[0] - 30.0 <= 9.0: |
| raise ValidationError("vertical board spacing is not approximately 8 mm") |
|
|
| origins = {} |
| for point in vcc: |
| col = _nearest_level(point[0], x_levels) |
| row = _nearest_level(point[1], y_levels) |
| if (row, col) in origins: |
| raise ValidationError("duplicate board-copy origin") |
| origins[(row, col)] = point |
| if set(origins) != {(row, col) for row in range(2) for col in range(3)}: |
| raise ValidationError("incomplete 3x2 board grid") |
| return origins, x_levels, y_levels |
|
|
|
|
| def _npth_holes(root): |
| holes = [] |
| all_pads = 0 |
| for footprint in _direct(root, "footprint"): |
| for pad in _direct(footprint, "pad"): |
| all_pads += 1 |
| if len(pad) < 4 or pad[2] != "np_thru_hole": |
| continue |
| if pad[1] != "" or pad[3] != "circle": |
| raise ValidationError("mouse-bite holes must be unnumbered circular NPTH pads") |
| if not _point_close(_pad_size(pad), (0.5, 0.5), TAB_TOL): |
| raise ValidationError("wrong mouse-bite pad size") |
| drill = _pad_drill(pad) |
| if len(drill) != 1 or not _close(drill[0], 0.5, TAB_TOL): |
| raise ValidationError("wrong mouse-bite drill") |
| if _layers(pad) != {"*.Cu", "*.Mask"}: |
| raise ValidationError("wrong mouse-bite pad layers") |
| if _direct(pad, "net"): |
| raise ValidationError("NPTH mouse-bite hole cannot have a net") |
| holes.append(_world_pad(footprint, pad)) |
| if all_pads != 52 or len(holes) != 40: |
| raise ValidationError("panel needs exactly twelve board pads and forty NPTH holes") |
| if len({(round(x, 4), round(y, 4)) for x, y in holes}) != 40: |
| raise ValidationError("mouse-bite holes overlap") |
| return holes |
|
|
|
|
| def _hole_groups(holes): |
| adjacency = {index: set() for index in range(len(holes))} |
| for left in range(len(holes)): |
| for right in range(left + 1, len(holes)): |
| dx = abs(holes[left][0] - holes[right][0]) |
| dy = abs(holes[left][1] - holes[right][1]) |
| adjacent = ( |
| dy <= TAB_TOL and abs(dx - 1.0) <= TAB_TOL |
| ) or ( |
| dx <= TAB_TOL and abs(dy - 1.0) <= TAB_TOL |
| ) |
| if adjacent: |
| adjacency[left].add(right) |
| adjacency[right].add(left) |
|
|
| groups = [] |
| remaining = set(range(len(holes))) |
| while remaining: |
| seed = next(iter(remaining)) |
| component = set() |
| frontier = [seed] |
| while frontier: |
| current = frontier.pop() |
| if current in component: |
| continue |
| component.add(current) |
| frontier.extend(adjacency[current] - component) |
| remaining -= component |
| points = [holes[index] for index in component] |
| if len(points) != 4: |
| raise ValidationError("each mouse-bite array must contain exactly four holes") |
| xs = sorted(point[0] for point in points) |
| ys = sorted(point[1] for point in points) |
| if max(ys) - min(ys) <= TAB_TOL: |
| orientation = "horizontal" |
| coordinates = xs |
| elif max(xs) - min(xs) <= TAB_TOL: |
| orientation = "vertical" |
| coordinates = ys |
| else: |
| raise ValidationError("mouse-bite array is not axis aligned") |
| if any(abs(right - left - 1.0) > TAB_TOL for left, right in zip(coordinates, coordinates[1:])): |
| raise ValidationError("mouse-bite pitch is not 1 mm") |
| groups.append( |
| { |
| "orientation": orientation, |
| "center": ( |
| sum(point[0] for point in points) / 4.0, |
| sum(point[1] for point in points) / 4.0, |
| ), |
| } |
| ) |
| if len(groups) != 10: |
| raise ValidationError("expected ten mouse-bite arrays") |
| return groups |
|
|
|
|
| def _take_group(groups, predicate, label: str): |
| matches = [index for index, group in enumerate(groups) if predicate(group)] |
| if len(matches) != 1: |
| raise ValidationError(f"expected exactly one mouse-bite array for {label}") |
| return groups.pop(matches[0]) |
|
|
|
|
| def _horizontal_line(line): |
| return _close(line[0][1], line[1][1]) |
|
|
|
|
| def _vertical_line(line): |
| return _close(line[0][0], line[1][0]) |
|
|
|
|
| def _find_rail(lines, origins, x_levels, y_levels): |
| minimum_y = min(point[1] for line in lines for point in line) |
| board_left = min(point[0] for point in origins.values()) - 2.244466 |
| board_right = max(point[0] for point in origins.values()) + 30.0 |
| top_candidates = [] |
| for segment in lines: |
| if not _horizontal_line(segment): |
| continue |
| start, end = sorted((segment[0][0], segment[1][0])) |
| if _close(segment[0][1], minimum_y) and start <= board_left + TOL and end >= board_right - TOL: |
| top_candidates.append((segment, start, end)) |
| if len(top_candidates) != 1: |
| raise ValidationError("expected one full-width top rail edge") |
| _, rail_left, rail_right = top_candidates[0] |
|
|
| def side_bottom(x): |
| candidates = [] |
| for segment in lines: |
| if not _vertical_line(segment) or not _close(segment[0][0], x): |
| continue |
| ys = sorted((segment[0][1], segment[1][1])) |
| if _close(ys[0], minimum_y) and ys[1] > minimum_y + TOL: |
| candidates.append(ys[1]) |
| if len(candidates) != 1: |
| raise ValidationError("rail must have two unambiguous side edges") |
| return candidates[0] |
|
|
| left_bottom = side_bottom(rail_left) |
| right_bottom = side_bottom(rail_right) |
| if not _close(left_bottom, right_bottom): |
| raise ValidationError("rail side edges have different heights") |
| rail_bottom = (left_bottom + right_bottom) / 2.0 |
| if not 0.5 <= rail_bottom - minimum_y <= 10.0: |
| raise ValidationError("invalid rail-strip depth") |
| if not 7.0 <= y_levels[0] - rail_bottom <= 9.0: |
| raise ValidationError("rail-to-board spacing is not approximately 8 mm") |
| if rail_right - rail_left > 180.0 + TOL: |
| raise ValidationError("rail exceeds maximum panel width") |
| return rail_left, rail_right, minimum_y, rail_bottom |
|
|
|
|
| def _split_interval(start: float, end: float, gaps): |
| low, high = sorted((start, end)) |
| normalized = sorted((max(low, a), min(high, b)) for a, b in gaps) |
| cursor = low |
| pieces = [] |
| for gap_start, gap_end in normalized: |
| if gap_start < cursor - TOL or gap_end <= gap_start + TOL or gap_end > high + TOL: |
| raise ValidationError("invalid or overlapping tab opening") |
| if gap_start > cursor + TOL: |
| pieces.append((cursor, gap_start)) |
| cursor = gap_end |
| if cursor < high - TOL: |
| pieces.append((cursor, high)) |
| return pieces |
|
|
|
|
| def _append_horizontal(expected, start: float, end: float, y: float, gaps=()): |
| expected.extend((((left, y), (right, y))) for left, right in _split_interval(start, end, gaps)) |
|
|
|
|
| def _append_vertical(expected, x: float, start: float, end: float, gaps=()): |
| expected.extend((((x, low), (x, high))) for low, high in _split_interval(start, end, gaps)) |
|
|
|
|
| def _check_panel_geometry(root, source_arcs): |
| origins, x_levels, y_levels = _panel_origins(root) |
| actual_lines = _edge_lines(root) |
| actual_arcs = _edge_arcs(root) |
| expected_arcs = [] |
| for origin in origins.values(): |
| for source_arc in source_arcs: |
| expected_arcs.append( |
| tuple((point[0] + origin[0], point[1] + origin[1]) for point in source_arc) |
| ) |
| _match_exact(actual_arcs, expected_arcs, _arc_close, "copied arc") |
|
|
| holes = _npth_holes(root) |
| groups = _hole_groups(holes) |
| rail_left, rail_right, rail_top, rail_bottom = _find_rail( |
| actual_lines, origins, x_levels, y_levels |
| ) |
|
|
| horizontal_tabs = {} |
| for row in range(2): |
| for col in range(2): |
| left = origins[(row, col)] |
| right = origins[(row, col + 1)] |
| gap_center = (left[0] + 30.0 + right[0]) / 2.0 |
| low = max(left[1], right[1] + 3.0) + 1.0 |
| high = min(left[1] + 20.0, right[1] + 30.0) - 1.0 |
| horizontal_tabs[(row, col)] = _take_group( |
| groups, |
| lambda group, center=gap_center, low=low, high=high: ( |
| group["orientation"] == "horizontal" |
| and _close(group["center"][0], center, TAB_TOL) |
| and low - TAB_TOL <= group["center"][1] <= high + TAB_TOL |
| ), |
| f"horizontal interface {row},{col}", |
| ) |
|
|
| vertical_tabs = {} |
| for col in range(3): |
| top = origins[(0, col)] |
| bottom = origins[(1, col)] |
| gap_center = (top[1] + 30.0 + bottom[1]) / 2.0 |
| vertical_tabs[col] = _take_group( |
| groups, |
| lambda group, left=top[0] + 1.0, right=top[0] + 19.0, center=gap_center: ( |
| group["orientation"] == "vertical" |
| and _close(group["center"][1], center, TAB_TOL) |
| and left - TAB_TOL <= group["center"][0] <= right + TAB_TOL |
| ), |
| f"vertical interface {col}", |
| ) |
|
|
| rail_tabs = {} |
| rail_gap_center = (rail_bottom + y_levels[0]) / 2.0 |
| for col in range(3): |
| origin = origins[(0, col)] |
| rail_tabs[col] = _take_group( |
| groups, |
| lambda group, left=origin[0] + 1.0, right=origin[0] + 29.0: ( |
| group["orientation"] == "vertical" |
| and _close(group["center"][1], rail_gap_center, TAB_TOL) |
| and left - TAB_TOL <= group["center"][0] <= right + TAB_TOL |
| ), |
| f"rail interface {col}", |
| ) |
| if groups: |
| raise ValidationError("unassigned mouse-bite arrays") |
|
|
| expected_lines = [] |
| for row in range(2): |
| for col in range(3): |
| ox, oy = origins[(row, col)] |
| top_tab = rail_tabs[col] if row == 0 else vertical_tabs[col] |
| top_x = top_tab["center"][0] |
| _append_horizontal(expected_lines, ox, ox + 30.0, oy, [(top_x - 1.0, top_x + 1.0)]) |
|
|
| if col < 2: |
| tab_y = horizontal_tabs[(row, col)]["center"][1] |
| _append_vertical(expected_lines, ox + 30.0, oy, oy + 20.0, [(tab_y - 1.0, tab_y + 1.0)]) |
| else: |
| _append_vertical(expected_lines, ox + 30.0, oy, oy + 20.0) |
| _append_horizontal(expected_lines, ox + 20.0, ox + 30.0, oy + 20.0) |
|
|
| if row == 0: |
| tab_x = vertical_tabs[col]["center"][0] |
| _append_horizontal(expected_lines, ox, ox + 20.0, oy + 30.0, [(tab_x - 1.0, tab_x + 1.0)]) |
| else: |
| _append_horizontal(expected_lines, ox, ox + 20.0, oy + 30.0) |
|
|
| if col > 0: |
| tab_y = horizontal_tabs[(row, col - 1)]["center"][1] |
| _append_vertical(expected_lines, ox, oy + 3.0, oy + 30.0, [(tab_y - 1.0, tab_y + 1.0)]) |
| else: |
| _append_vertical(expected_lines, ox, oy + 3.0, oy + 30.0) |
|
|
| for row in range(2): |
| for col in range(2): |
| left = origins[(row, col)] |
| right = origins[(row, col + 1)] |
| center = horizontal_tabs[(row, col)]["center"] |
| _append_horizontal(expected_lines, left[0] + 30.0, right[0], center[1] - 1.0) |
| _append_horizontal(expected_lines, left[0] + 30.0, right[0], center[1] + 1.0) |
|
|
| for col in range(3): |
| top = origins[(0, col)] |
| bottom = origins[(1, col)] |
| center = vertical_tabs[col]["center"] |
| _append_vertical(expected_lines, center[0] - 1.0, top[1] + 30.0, bottom[1]) |
| _append_vertical(expected_lines, center[0] + 1.0, top[1] + 30.0, bottom[1]) |
|
|
| _append_horizontal(expected_lines, rail_left, rail_right, rail_top) |
| _append_vertical(expected_lines, rail_left, rail_top, rail_bottom) |
| _append_vertical(expected_lines, rail_right, rail_top, rail_bottom) |
| rail_gaps = [] |
| for col in range(3): |
| center = rail_tabs[col]["center"] |
| rail_gaps.append((center[0] - 1.0, center[0] + 1.0)) |
| _append_vertical(expected_lines, center[0] - 1.0, rail_bottom, y_levels[0]) |
| _append_vertical(expected_lines, center[0] + 1.0, rail_bottom, y_levels[0]) |
| _append_horizontal(expected_lines, rail_left, rail_right, rail_bottom, rail_gaps) |
|
|
| _match_exact(actual_lines, expected_lines, _segment_close, "Edge.Cuts line") |
|
|
| points = [point for segment in actual_lines for point in segment] |
| points.extend(point for arc_item in actual_arcs for point in arc_item) |
| points.extend(holes) |
| width = max(point[0] for point in points) - min(point[0] for point in points) |
| height = max(point[1] for point in points) - min(point[1] for point in points) |
| if width > 180.0 + TOL or height > 120.0 + TOL: |
| raise ValidationError("panel exceeds 180x120 mm") |
|
|
|
|
| def _run(command, timeout=60): |
| completed = subprocess.run( |
| [str(item) for item in command], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| text=True, |
| timeout=timeout, |
| check=False, |
| ) |
| if completed.returncode != 0: |
| raise ValidationError(completed.stderr or completed.stdout or "KiCad command failed") |
| return completed.stdout |
|
|
|
|
| def _normalize_svg(text: str): |
| if "<desc>Image generated by PCBNEW </desc>" not in text: |
| raise ValidationError("SVG is not a native PCBNEW export") |
| normalized, count = re.subn( |
| r"<title>SVG Image created as edgecuts\.svg date [^<]+</title>", |
| "<title>SVG Image created as edgecuts.svg date TIMESTAMP </title>", |
| text, |
| ) |
| if count != 1: |
| raise ValidationError("invalid native SVG title") |
| return normalized.replace("\r\n", "\n") |
|
|
|
|
| def _normalize_drill(text: str): |
| if "; #@! TF.GenerationSoftware,Kicad,Pcbnew,10.0.2-10.0.2~ubuntu24.04.1" not in text: |
| raise ValidationError("drill file was not generated by snapshot KiCad 10.0.2") |
| text, header_count = re.subn( |
| r"(?m)^(; DRILL file KiCad 10\.0\.2-10\.0\.2~ubuntu24\.04\.1 date )[^\r\n]+$", |
| r"\1TIMESTAMP", |
| text, |
| ) |
| text, creation_count = re.subn( |
| r"(?m)^(; #@! TF\.CreationDate,)[^\r\n]+$", |
| r"\1TIMESTAMP", |
| text, |
| ) |
| if header_count != 1 or creation_count != 1: |
| raise ValidationError("invalid native drill metadata") |
| return text.replace("\r\n", "\n") |
|
|
|
|
| def _native_validate(panel_path: Path, svg_path: Path, drill_path: Path) -> None: |
| if not KICAD_CLI.is_file() or not os.access(KICAD_CLI, os.X_OK): |
| raise ValidationError("KiCad CLI is unavailable") |
| version = _run([KICAD_CLI, "version", "--format", "about"]) |
| if "Version: 10.0.2-10.0.2~ubuntu24.04.1" not in version: |
| raise ValidationError("wrong KiCad CLI build") |
| with tempfile.TemporaryDirectory(prefix="engiworld-kicad-task-20-") as temporary: |
| root = Path(temporary) |
| native_panel = root / "panel.kicad_pcb" |
| shutil.copy2(panel_path, native_panel) |
| _run([KICAD_CLI, "pcb", "upgrade", "--force", native_panel]) |
|
|
| native_svg = root / "edgecuts.svg" |
| _run( |
| [ |
| KICAD_CLI, |
| "pcb", |
| "export", |
| "svg", |
| "--layers", |
| "Edge.Cuts", |
| "--exclude-drawing-sheet", |
| "--page-size-mode", |
| "2", |
| "--drill-shape-opt", |
| "2", |
| "--black-and-white", |
| "--mode-single", |
| "--output", |
| native_svg, |
| native_panel, |
| ] |
| ) |
| _run([KICAD_CLI, "pcb", "export", "drill", "--output", root, native_panel]) |
| native_drill = root / "panel.drl" |
| if not native_svg.is_file() or not native_drill.is_file(): |
| raise ValidationError("KiCad did not create required native exports") |
| if _normalize_svg(svg_path.read_text(encoding="utf-8")) != _normalize_svg( |
| native_svg.read_text(encoding="utf-8") |
| ): |
| raise ValidationError("edgecuts.svg does not match the native export") |
| if _normalize_drill(drill_path.read_text(encoding="utf-8")) != _normalize_drill( |
| native_drill.read_text(encoding="utf-8") |
| ): |
| raise ValidationError("panel.drl does not match the native export") |
|
|
|
|
| def evaluate(desktop: Path = DESKTOP) -> bool: |
| source_path = desktop / "A.kicad_pcb" |
| panel_path = desktop / "panel.kicad_pcb" |
| svg_path = desktop / "edgecuts.svg" |
| drill_path = desktop / "panel.drl" |
| source = _read_board(source_path) |
| panel = _read_board(panel_path) |
| source_arcs = _check_source(source) |
| _check_header(panel, "PNL02 Panel 3x2 of Board A") |
| _check_panel_geometry(panel, source_arcs) |
| _native_validate(panel_path, svg_path, drill_path) |
| return True |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = evaluate() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
|
|
