| from __future__ import annotations |
|
|
| import csv |
| import json |
| import os |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
|
|
| DESKTOP = Path("/home/user/Desktop") |
| KICAD_CLI = Path("/usr/bin/kicad-cli") |
| OUTPUT_NAMES = ( |
| "board.kicad_pro", |
| "design.kicad_sch", |
| "design.kicad_pcb", |
| "project.kicad_sym", |
| ) |
| REQUIRED_REFERENCES = {"R1", "C1", "D1", "Q1", "U1"} |
| REQUIRED_LAYERS = {"F.Cu", "B.Cu", "F.SilkS", "B.SilkS", "Edge.Cuts"} |
| EXPECTED_COMPONENTS = { |
| "R1": ("Device:R", "10k", {"1", "2"}), |
| "C1": ("Device:C", "100nF", {"1", "2"}), |
| "D1": ("Device:LED", "LED", {"1", "2"}), |
| "Q1": ("Transistor_BJT:Q_NPN_BCE", "BC547", {"1", "2", "3"}), |
| "U1": ("Regulator_Linear:LM7805_TO220", "LM7805", {"1", "2", "3"}), |
| } |
| EXPECTED_NET_NODES = { |
| "+5V": {("U1", "3")}, |
| "GND": {("C1", "2"), ("Q1", "3"), ("R1", "2"), ("U1", "2")}, |
| "SIG_A": {("D1", "2"), ("Q1", "1")}, |
| "SIG_B": {("D1", "1"), ("Q1", "2")}, |
| "VCC": {("C1", "1"), ("R1", "1"), ("U1", "1")}, |
| } |
| EXPECTED_FOOTPRINTS = { |
| "R1": { |
| "library": "Resistors_SMD:R_0603", |
| "at": (20.0, 20.0), |
| "pads": { |
| "1": ("smd", "rect", (-0.8, 0.0), (0.9, 1.2), None, {"F.Cu", "F.Mask", "F.Paste"}), |
| "2": ("smd", "rect", (0.8, 0.0), (0.9, 1.2), None, {"F.Cu", "F.Mask", "F.Paste"}), |
| }, |
| }, |
| "C1": { |
| "library": "Capacitors_SMD:C_0402", |
| "at": (30.0, 20.0), |
| "pads": { |
| "1": ("smd", "rect", (-0.5, 0.0), (0.6, 0.7), None, {"F.Cu", "F.Mask", "F.Paste"}), |
| "2": ("smd", "rect", (0.5, 0.0), (0.6, 0.7), None, {"F.Cu", "F.Mask", "F.Paste"}), |
| }, |
| }, |
| "D1": { |
| "library": "LEDs:LED_0603", |
| "at": (40.0, 20.0), |
| "pads": { |
| "1": ("smd", "rect", (-0.8, 0.0), (0.9, 1.2), None, {"F.Cu", "F.Mask", "F.Paste"}), |
| "2": ("smd", "rect", (0.8, 0.0), (0.9, 1.2), None, {"F.Cu", "F.Mask", "F.Paste"}), |
| }, |
| }, |
| "Q1": { |
| "library": "TO_SOT_Packages_THT:TO-92_Inline", |
| "at": (50.0, 20.0), |
| "pads": { |
| "1": ("thru_hole", "circle", (-1.27, 0.0), (1.6, 1.6), (0.8,), {"*.Cu", "*.Mask"}), |
| "2": ("thru_hole", "circle", (0.0, 0.0), (1.6, 1.6), (0.8,), {"*.Cu", "*.Mask"}), |
| "3": ("thru_hole", "circle", (1.27, 0.0), (1.6, 1.6), (0.8,), {"*.Cu", "*.Mask"}), |
| }, |
| }, |
| "U1": { |
| "library": "TO_SOT_Packages_THT:TO-220_Vertical", |
| "at": (60.0, 20.0), |
| "pads": { |
| "1": ("thru_hole", "rect", (-2.54, 0.0), (2.4, 2.4), (1.3,), {"*.Cu", "*.Mask"}), |
| "2": ("thru_hole", "oval", (0.0, 0.0), (2.4, 2.4), (1.3,), {"*.Cu", "*.Mask"}), |
| "3": ("thru_hole", "circle", (2.54, 0.0), (2.4, 2.4), (1.3,), {"*.Cu", "*.Mask"}), |
| }, |
| }, |
| } |
| EXPECTED_LIBRARY_SYMBOLS = { |
| "R": ( |
| "R", |
| "R", |
| "R", |
| {"1": ("passive", {"", "~"}), "2": ("passive", {"", "~"})}, |
| ), |
| "C": ( |
| "C", |
| "C", |
| "C", |
| {"1": ("passive", {"", "~"}), "2": ("passive", {"", "~"})}, |
| ), |
| "LED": ( |
| "LED", |
| "D", |
| "LED", |
| {"1": ("passive", {"K"}), "2": ("passive", {"A"})}, |
| ), |
| "Q_NPN_BCE": ( |
| "Q", |
| "Q", |
| "Q_NPN_BCE", |
| { |
| "1": ("input", {"B"}), |
| "2": ("passive", {"C"}), |
| "3": ("passive", {"E"}), |
| }, |
| ), |
| "BC547": ( |
| "Q", |
| "Q", |
| "BC547", |
| { |
| "1": ("input", {"B"}), |
| "2": ("passive", {"C"}), |
| "3": ("passive", {"E"}), |
| }, |
| ), |
| "LM7805_TO220": ( |
| "U", |
| "U", |
| "LM7805_TO220", |
| { |
| "1": ("input", {"VI"}), |
| "2": ("power_in", {"GND"}), |
| "3": ("output", {"VO"}), |
| }, |
| ), |
| "LM7805": ( |
| "U", |
| "U", |
| "LM7805", |
| { |
| "1": ("input", {"IN"}), |
| "2": ("power_in", {"GND"}), |
| "3": ("output", {"OUT"}), |
| }, |
| ), |
| } |
| EXPECTED_TARGET_PINS = { |
| "Device:R": { |
| "1": ("passive", {"", "~"}), |
| "2": ("passive", {"", "~"}), |
| }, |
| "Device:C": { |
| "1": ("passive", {"", "~"}), |
| "2": ("passive", {"", "~"}), |
| }, |
| "Device:LED": { |
| "1": ("passive", {"K"}), |
| "2": ("passive", {"A"}), |
| }, |
| "Transistor_BJT:Q_NPN_BCE": { |
| "1": ("input", {"B"}), |
| "2": ("passive", {"C"}), |
| "3": ("passive", {"E"}), |
| }, |
| "Regulator_Linear:LM7805_TO220": { |
| "1": ("power_in", {"VI"}), |
| "2": ("power_in", {"GND"}), |
| "3": ("power_out", {"VO"}), |
| }, |
| } |
| SYMBOL_GRAPHICS = {"arc", "bezier", "circle", "polyline", "rectangle", "text", "text_box"} |
| EXPECTED_VERSIONS = { |
| "kicad_sch": "20260306", |
| "kicad_pcb": "20260206", |
| "kicad_symbol_lib": "20251024", |
| } |
|
|
|
|
| class SexpError(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 SexpError("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 SexpError("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 SexpError("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 SexpError("invalid token") |
| append(text[start:index]) |
|
|
| if stack: |
| raise SexpError("unterminated list") |
| if len(roots) != 1 or not isinstance(roots[0], list): |
| raise SexpError("expected one root list") |
| 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_value(node, name: str): |
| matches = _direct(node, name) |
| if len(matches) != 1 or len(matches[0]) < 2 or isinstance(matches[0][1], list): |
| raise SexpError(f"expected one scalar {name}") |
| return matches[0][1] |
|
|
|
|
| def _single_node(node, name: str): |
| matches = _direct(node, name) |
| if len(matches) != 1: |
| raise SexpError(f"expected one {name} node") |
| return matches[0] |
|
|
|
|
| def _float_values(node, name: str, count: int): |
| match = _single_node(node, name) |
| values = match[1 : count + 1] |
| if len(values) != count or any(isinstance(value, list) for value in values): |
| raise SexpError(f"invalid numeric {name}") |
| try: |
| return tuple(float(value) for value in values) |
| except ValueError as exc: |
| raise SexpError(f"invalid numeric {name}") from exc |
|
|
|
|
| def _close_tuple(observed, expected, tolerance=1e-6): |
| return len(observed) == len(expected) and all( |
| abs(left - right) <= tolerance for left, right in zip(observed, expected) |
| ) |
|
|
|
|
| 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 SexpError(f"expected one {name} property") |
| return matches[0][2] |
|
|
|
|
| def _walk(node): |
| if not isinstance(node, list): |
| return |
| yield node |
| for child in node: |
| if isinstance(child, list): |
| yield from _walk(child) |
|
|
|
|
| def _read_sexp(path: Path): |
| return _parse_sexp(path.read_text(encoding="utf-8")) |
|
|
|
|
| def _check_root(root, expected_head: str): |
| if _head(root) != expected_head: |
| raise SexpError(f"expected {expected_head} root") |
| if _single_value(root, "version") != EXPECTED_VERSIONS[expected_head]: |
| raise SexpError(f"wrong {expected_head} version") |
| if _single_value(root, "generator_version") != "10.0": |
| raise SexpError(f"wrong {expected_head} generator version") |
|
|
|
|
| def _load_target_ids(path: Path): |
| with path.open(newline="", encoding="utf-8") as handle: |
| reader = csv.DictReader(handle) |
| if reader.fieldnames != ["v5_lib_id", "v9_lib_id"]: |
| raise ValueError("invalid lib_map.csv header") |
| rows = list(reader) |
| targets = {row["v9_lib_id"].strip() for row in rows} |
| if len(rows) != 5 or len(targets) != 5 or "" in targets: |
| raise ValueError("lib_map.csv must contain five unique mappings") |
| return targets |
|
|
|
|
| def _check_project(path: Path): |
| project = json.loads(path.read_text(encoding="utf-8")) |
| if not isinstance(project, dict): |
| raise ValueError("project root is not an object") |
| meta = project.get("meta") |
| if not isinstance(meta, dict): |
| raise ValueError("missing project meta") |
| if meta.get("filename") != "board.kicad_pro" or meta.get("version") != 3: |
| raise ValueError("wrong KiCad project metadata") |
| for key in ("net_settings", "schematic", "pcbnew"): |
| if not isinstance(project.get(key), dict): |
| raise ValueError(f"missing project object {key}") |
| net_settings = project["net_settings"] |
| if net_settings.get("meta") != {"version": 5}: |
| raise ValueError("wrong net-settings metadata") |
| classes = net_settings.get("classes") |
| if not isinstance(classes, list) or not any( |
| isinstance(item, dict) and item.get("name") == "Default" for item in classes |
| ): |
| raise ValueError("missing Default net class") |
| if project["schematic"].get("meta") != {"version": 1}: |
| raise ValueError("wrong schematic project metadata") |
| if not isinstance(project["pcbnew"].get("last_paths"), dict): |
| raise ValueError("missing PCB project paths") |
|
|
|
|
| def _check_schematic(path: Path, target_ids): |
| root = _read_sexp(path) |
| _check_root(root, "kicad_sch") |
| if _single_value(root, "generator") != "eeschema": |
| raise SexpError("wrong schematic generator") |
|
|
| label_names = { |
| label[1] |
| for label in _direct(root, "label") |
| if len(label) >= 2 and not isinstance(label[1], list) |
| } |
| if label_names != set(EXPECTED_NET_NODES): |
| raise SexpError("schematic labels do not match the five source nets") |
|
|
| embedded_section = _single_node(root, "lib_symbols") |
| embedded = _direct(embedded_section, "symbol") |
| embedded_by_id = { |
| symbol[1]: symbol |
| for symbol in embedded |
| if len(symbol) >= 2 and not isinstance(symbol[1], list) |
| } |
| if set(embedded_by_id) != target_ids or len(embedded_by_id) != len(embedded): |
| raise SexpError("embedded symbols do not match the migration targets") |
| for lib_id, symbol in embedded_by_id.items(): |
| if not any(_head(node) in SYMBOL_GRAPHICS for node in _walk(symbol)): |
| raise SexpError(f"embedded symbol has no graphics: {lib_id}") |
| expected_pins = EXPECTED_TARGET_PINS[lib_id] |
| pins = {} |
| for pin in (node for node in _walk(symbol) if _head(node) == "pin"): |
| number = _single_value(pin, "number") |
| if number in pins: |
| raise SexpError(f"duplicate embedded pin {lib_id}:{number}") |
| pins[number] = (pin[1], _single_value(pin, "name")) |
| if set(pins) != set(expected_pins): |
| raise SexpError(f"wrong embedded pin numbering: {lib_id}") |
| for number, (pin_type, pin_name) in pins.items(): |
| expected_type, allowed_names = expected_pins[number] |
| if pin_type != expected_type or pin_name not in allowed_names: |
| raise SexpError(f"wrong embedded pin semantics: {lib_id}:{number}") |
|
|
| placed = _direct(root, "symbol") |
| if len(placed) != len(EXPECTED_COMPONENTS): |
| raise SexpError("migration must preserve exactly five placed symbols") |
| observed = {} |
| for symbol in placed: |
| reference = _property(symbol, "Reference") |
| lib_id = _single_value(symbol, "lib_id") |
| value = _property(symbol, "Value") |
| if lib_id not in target_ids: |
| raise SexpError(f"unmapped placed symbol {lib_id}") |
| if reference in observed: |
| raise SexpError(f"duplicate placed reference {reference}") |
| observed[reference] = (lib_id, value) |
| expected = { |
| reference: (lib_id, value) |
| for reference, (lib_id, value, _) in EXPECTED_COMPONENTS.items() |
| } |
| if observed != expected: |
| raise SexpError("placed reference, library id, or value was not preserved") |
|
|
|
|
| def _check_pcb(path: Path): |
| root = _read_sexp(path) |
| _check_root(root, "kicad_pcb") |
| if _single_value(root, "generator") != "pcbnew": |
| raise SexpError("wrong PCB generator") |
|
|
| general = _single_node(root, "general") |
| if _single_value(general, "thickness") != "1.6": |
| raise SexpError("PCB thickness was not preserved") |
| title_block = _single_node(root, "title_block") |
| expected_title = { |
| "title": "Legacy Power Board", |
| "date": "2015-04-28", |
| "rev": "A", |
| "company": "ACME Corp", |
| } |
| for field, value in expected_title.items(): |
| if _single_value(title_block, field) != value: |
| raise SexpError(f"PCB title-block field was not preserved: {field}") |
|
|
| layers_nodes = _direct(root, "layers") |
| if len(layers_nodes) != 1: |
| raise SexpError("missing layers section") |
| layer_names = { |
| child[1] |
| for child in layers_nodes[0][1:] |
| if isinstance(child, list) |
| and len(child) >= 2 |
| and not isinstance(child[1], list) |
| } |
| if not REQUIRED_LAYERS.issubset(layer_names): |
| raise SexpError("missing canonical KiCad layers") |
|
|
| footprints = _direct(root, "footprint") |
| if len(footprints) != len(EXPECTED_COMPONENTS): |
| raise SexpError("migration must preserve exactly five footprints") |
| observed = {} |
| for footprint in footprints: |
| if len(footprint) < 2 or isinstance(footprint[1], list): |
| raise SexpError("footprint lacks a library identifier") |
| reference = _property(footprint, "Reference") |
| value = _property(footprint, "Value") |
| if len(_direct(footprint, "layer")) != 1 or not _direct(footprint, "pad"): |
| raise SexpError("footprint lacks native layer or pad structure") |
| if reference in observed: |
| raise SexpError(f"duplicate footprint reference {reference}") |
| if reference not in EXPECTED_FOOTPRINTS: |
| raise SexpError(f"unexpected footprint reference {reference}") |
| expected = EXPECTED_FOOTPRINTS[reference] |
| if footprint[1] != expected["library"]: |
| raise SexpError(f"footprint library ID was not preserved: {reference}") |
| if not _close_tuple(_float_values(footprint, "at", 2), expected["at"]): |
| raise SexpError(f"footprint position was not preserved: {reference}") |
| expected_value = EXPECTED_COMPONENTS[reference][1] |
| if value != expected_value: |
| raise SexpError(f"footprint value was not preserved: {reference}") |
|
|
| pads = {} |
| for pad in _direct(footprint, "pad"): |
| if len(pad) < 4 or any(isinstance(value, list) for value in pad[1:4]): |
| raise SexpError(f"invalid pad structure: {reference}") |
| number, pad_type, shape = pad[1:4] |
| if number in pads: |
| raise SexpError(f"duplicate pad number: {reference}.{number}") |
| at = _float_values(pad, "at", 2) |
| size = _float_values(pad, "size", 2) |
| drill_nodes = _direct(pad, "drill") |
| if len(drill_nodes) > 1: |
| raise SexpError(f"duplicate drill node: {reference}.{number}") |
| drill = None |
| if drill_nodes: |
| raw_drill = drill_nodes[0][1:] |
| if not raw_drill or any(isinstance(item, list) for item in raw_drill): |
| raise SexpError(f"invalid drill: {reference}.{number}") |
| if raw_drill[0] == "oval": |
| raw_drill = raw_drill[1:] |
| try: |
| drill = tuple(float(item) for item in raw_drill) |
| except ValueError as exc: |
| raise SexpError(f"invalid drill: {reference}.{number}") from exc |
| layers = _single_node(pad, "layers") |
| layer_set = { |
| item for item in layers[1:] if not isinstance(item, list) |
| } |
| pads[number] = (pad_type, shape, at, size, drill, layer_set) |
|
|
| if set(pads) != set(expected["pads"]): |
| raise SexpError(f"pad numbering was not preserved: {reference}") |
| for number, details in pads.items(): |
| expected_details = expected["pads"][number] |
| if details[:2] != expected_details[:2]: |
| raise SexpError(f"pad type or shape was not preserved: {reference}.{number}") |
| if not _close_tuple(details[2], expected_details[2]): |
| raise SexpError(f"pad position was not preserved: {reference}.{number}") |
| if not _close_tuple(details[3], expected_details[3]): |
| raise SexpError(f"pad size was not preserved: {reference}.{number}") |
| if details[4] is None or expected_details[4] is None: |
| if details[4] != expected_details[4]: |
| raise SexpError(f"pad drill was not preserved: {reference}.{number}") |
| elif not _close_tuple(details[4], expected_details[4]): |
| raise SexpError(f"pad drill was not preserved: {reference}.{number}") |
| if details[5] != expected_details[5]: |
| raise SexpError(f"pad layers were not preserved: {reference}.{number}") |
| observed[reference] = True |
| if set(observed) != set(EXPECTED_FOOTPRINTS): |
| raise SexpError("PCB footprint set was not preserved") |
| if _direct(root, "module"): |
| raise SexpError("legacy module structure remains") |
|
|
|
|
| def _check_symbol_library(path: Path, target_ids): |
| root = _read_sexp(path) |
| _check_root(root, "kicad_symbol_lib") |
| if _single_value(root, "generator") != "kicad_symbol_editor": |
| raise SexpError("wrong symbol-library generator") |
| symbols = _direct(root, "symbol") |
| if len(symbols) != 5: |
| raise SexpError("local library must contain exactly five top-level symbols") |
| names = [ |
| symbol[1] |
| for symbol in symbols |
| if len(symbol) >= 2 and not isinstance(symbol[1], list) |
| ] |
| if len(names) != len(symbols) or len(set(names)) != len(names): |
| raise SexpError("invalid or duplicate top-level symbol name") |
| canonical_names = { |
| EXPECTED_LIBRARY_SYMBOLS[name][0] |
| for name in names |
| if name in EXPECTED_LIBRARY_SYMBOLS |
| } |
| if canonical_names != {"R", "C", "LED", "Q", "U"}: |
| raise SexpError("local library does not freeze the five source symbols") |
| for symbol in symbols: |
| name = symbol[1] |
| _, expected_reference, expected_value, expected_pins = EXPECTED_LIBRARY_SYMBOLS[name] |
| if ( |
| _property(symbol, "Reference") != expected_reference |
| or _property(symbol, "Value") != expected_value |
| ): |
| raise SexpError(f"wrong properties in local symbol {name}") |
| if not any(_head(node) in SYMBOL_GRAPHICS for node in _walk(symbol)): |
| raise SexpError(f"local symbol has no graphics: {name}") |
| pins = {} |
| for pin in (node for node in _walk(symbol) if _head(node) == "pin"): |
| if len(pin) < 2 or isinstance(pin[1], list): |
| raise SexpError(f"invalid pin in local symbol {name}") |
| number = _single_value(pin, "number") |
| if number in pins: |
| raise SexpError(f"duplicate pin {number} in local symbol {name}") |
| pins[number] = (pin[1], _single_value(pin, "name")) |
| if set(pins) != set(expected_pins): |
| raise SexpError(f"wrong pin numbering in {name}") |
| for number, (pin_type, pin_name) in pins.items(): |
| expected_type, allowed_names = expected_pins[number] |
| if pin_type != expected_type or pin_name not in allowed_names: |
| raise SexpError(f"wrong pin name or electrical type in {name}") |
|
|
|
|
| def _run_cli(args, timeout=30): |
| completed = subprocess.run( |
| [str(KICAD_CLI), *map(str, args)], |
| capture_output=True, |
| text=True, |
| timeout=timeout, |
| check=False, |
| ) |
| if completed.returncode != 0: |
| detail = completed.stderr.strip() or completed.stdout.strip() |
| raise RuntimeError(f"kicad-cli failed: {detail}") |
| return completed.stdout |
|
|
|
|
| def _check_exported_nets(netlist_path: Path): |
| root = _read_sexp(netlist_path) |
| if _head(root) != "export": |
| raise SexpError("invalid exported netlist") |
| sections = _direct(root, "nets") |
| if len(sections) != 1: |
| raise SexpError("missing exported nets section") |
|
|
| named_nodes = {} |
| for net in _direct(sections[0], "net"): |
| name = _single_value(net, "name") |
| canonical_name = name[1:] if name.startswith("/") else name |
| if canonical_name in named_nodes: |
| raise SexpError(f"duplicate exported net: {canonical_name}") |
| nodes = set() |
| for node in _direct(net, "node"): |
| member = (_single_value(node, "ref"), _single_value(node, "pin")) |
| if member in nodes: |
| raise SexpError(f"duplicate node on exported net: {canonical_name}") |
| nodes.add(member) |
| named_nodes[canonical_name] = nodes |
| if named_nodes != EXPECTED_NET_NODES: |
| raise SexpError("exported electrical topology does not match the source") |
|
|
|
|
| def _check_with_kicad_cli(paths): |
| if not KICAD_CLI.is_file(): |
| raise RuntimeError("kicad-cli is unavailable") |
| if _run_cli(["version"]).strip() != "10.0.2": |
| raise RuntimeError("wrong KiCad version") |
|
|
| with tempfile.TemporaryDirectory(prefix="engiworld-kicad-task-08-") as temp: |
| temp_dir = Path(temp) |
| schematic = temp_dir / "design.kicad_sch" |
| pcb = temp_dir / "design.kicad_pcb" |
| symbols = temp_dir / "project.kicad_sym" |
| netlist = temp_dir / "design.net" |
| shutil.copy2(paths["design.kicad_sch"], schematic) |
| shutil.copy2(paths["design.kicad_pcb"], pcb) |
| shutil.copy2(paths["project.kicad_sym"], symbols) |
| shutil.copy2(paths["board.kicad_pro"], temp_dir / "design.kicad_pro") |
|
|
| _run_cli(["sch", "upgrade", "--force", schematic]) |
| _run_cli(["pcb", "upgrade", "--force", pcb]) |
| _run_cli(["sym", "upgrade", "--force", symbols]) |
| _run_cli( |
| [ |
| "sch", |
| "export", |
| "netlist", |
| "--format", |
| "kicadsexpr", |
| "--output", |
| netlist, |
| schematic, |
| ] |
| ) |
| _check_exported_nets(netlist) |
|
|
|
|
| def evaluate(): |
| paths = {name: DESKTOP / name for name in OUTPUT_NAMES} |
| if any(not path.is_file() for path in paths.values()): |
| return False |
| for path in paths.values(): |
| if path.stat().st_size > 64 * 1024 * 1024: |
| return False |
| if b"EESchema" in path.read_bytes(): |
| return False |
|
|
| target_ids = _load_target_ids(DESKTOP / "lib_map.csv") |
| _check_project(paths["board.kicad_pro"]) |
| _check_schematic(paths["design.kicad_sch"], target_ids) |
| _check_pcb(paths["design.kicad_pcb"]) |
| _check_symbol_library(paths["project.kicad_sym"], target_ids) |
| _check_with_kicad_cli(paths) |
| return True |
|
|
|
|
| def main(): |
| try: |
| result = evaluate() |
| except Exception as exc: |
| if os.environ.get("ENGIWORLD_EVAL_DEBUG") == "1": |
| print(f"{type(exc).__name__}: {exc}", file=sys.stderr) |
| result = False |
| print("True" if result else "False") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
