kcaa 0.2.0__tar.gz → 0.2.2__tar.gz

{kcaa-0.2.0 → kcaa-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kcaa
-Version: 0.2.0
+Version: 0.2.2
 Summary: Model Context Protocol (MCP) server for KiCad electronic design automation (EDA) files
 Project-URL: Homepage, https://github.com/paul356/KiCad-AI-Assistant
 Project-URL: Bug Tracker, https://github.com/paul356/KiCad-AI-Assistant/issues
@@ -24,6 +24,7 @@ Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: certifi>=2026.2.25
 Requires-Dist: defusedxml>=0.7.0
 Requires-Dist: fastmcp>=2.0.0
 Requires-Dist: kicad-python>=0.7.1
@@ -298,7 +299,7 @@ kcaa
 |------|-------------|
 | `get_board_info` | Get basic PCB board information |
 | `list_footprints` | List all footprints placed on the board |
-| `get_footprint` | Get details of a single placed footprint |
+| `get_footprint` | Get details of a placed footprint (pads, properties, Edge.Cuts geometry) |
 | `get_footprint_bbox` | Get the courtyard bounding box of a footprint |
 | `get_board_bounding_box` | Get the union bounding box of all footprints |
 | `list_nets` | List all nets on the board |

{kcaa-0.2.0 → kcaa-0.2.2}/README.md

@@ -260,7 +260,7 @@ kcaa
 |------|-------------|
 | `get_board_info` | Get basic PCB board information |
 | `list_footprints` | List all footprints placed on the board |
-| `get_footprint` | Get details of a single placed footprint |
+| `get_footprint` | Get details of a placed footprint (pads, properties, Edge.Cuts geometry) |
 | `get_footprint_bbox` | Get the courtyard bounding box of a footprint |
 | `get_board_bounding_box` | Get the union bounding box of all footprints |
 | `list_nets` | List all nets on the board |

{kcaa-0.2.0 → kcaa-0.2.2}/kcaa/resources/netlist_resources.py

@@ -7,7 +7,7 @@ import os
 from fastmcp import FastMCP
 
 from kcaa.utils.file_utils import get_project_files
-from kcaa.utils.netlist_parser import analyze_netlist, extract_netlist
+from kcaa.utils.netlist_parser import analyze_netlist, extract_netlist, iter_component_pins
 
 
 def register_netlist_resources(mcp: FastMCP) -> None:
@@ -210,12 +210,16 @@ def register_netlist_resources(mcp: FastMCP) -> None:
 
             report += "\n"
 
-            # Pins section
-            if "pins" in component_info:
+            # Pins section — pins are nested per unit (issue #89); list them flat,
+            # tagging the unit only for multi-unit components.
+            units = component_info.get("units") or {}
+            if units:
+                multi_unit = len(units) > 1
                 report += "## Pins\n\n"
 
-                for pin in component_info["pins"]:
-                    report += f"- **Pin {pin['num']}**: {pin['name']}\n"
+                for unit, pin in iter_component_pins(component_info):
+                    suffix = f" (unit {unit})" if multi_unit else ""
+                    report += f"- **Pin {pin['num']}{suffix}**: {pin['name']}\n"
 
                 report += "\n"
 

{kcaa-0.2.0 → kcaa-0.2.2}/kcaa/router/grid_a_star.py

@@ -56,6 +56,14 @@ _DIRECTIONS = [
 _CARD_COST = 1.0
 _DIAG_COST = math.sqrt(2.0)
 
+# Turn penalty (mm-equivalent) added when the path changes direction.
+# 0.3 mm ≈ 3 cells at 0.1 mm resolution — discourages zigzag without
+# blocking legitimate detours.  Set to 0 to disable (pure shortest path).
+_TURN_PENALTY = 0.3
+
+# Number of movement directions (8-directional grid).
+_N_DIRS = 8
+
 # Default via cost (mm added to the path for each via transition).
 _VIA_COST = 2.0
 
@@ -231,7 +239,9 @@ def _octile_dist(gx: int, gy: int, ex: int, ey: int) -> float:
     """Octile distance heuristic (admissible for 8-direction movement)."""
     dx = abs(gx - ex)
     dy = abs(gy - ey)
-    return _CARD_COST * abs(dx - dy) + (_DIAG_COST - _CARD_COST) * min(dx, dy)
+    if dx > dy:
+        return _DIAG_COST * dy + (dx - dy)
+    return _DIAG_COST * dx + (dy - dx)
 
 
 def grid_a_star(
@@ -243,6 +253,7 @@ def grid_a_star(
     via_from: dict[int, set[int]] | None = None,
     via_cost: float = _VIA_COST,
     via_forbidden_zones: list | None = None,
+    turn_penalty: float = _TURN_PENALTY,
 ) -> AStarResult:
     """Run A* on one or more walkability grids.
 
@@ -265,6 +276,8 @@ def grid_a_star(
         via_cost: Distance-equivalent cost per via transition (mm).
         via_forbidden_zones: Optional list of ``shapely`` Polygon objects
             where vias are forbidden (e.g. start/end pad AABBs).
+        turn_penalty: Distance-equivalent cost added when the path
+            changes direction.  0 disables (pure shortest path).
 
     Returns:
         :class:`AStarResult` with ``path`` as ``list[(x, y, layer_idx)]``,
@@ -288,13 +301,21 @@ def grid_a_star(
     if not grids[end_layer_idx].is_free(ex, ey):
         return AStarResult(path=None)
 
-    def _encode(gx: int, gy: int, li: int) -> int:
-        return (gy * W + gx) * n_layers + li
+    # State encoding: (cell, layer, arrival_direction).
+    # arrival_direction is 0-7 (index into _DIRECTIONS) or _N_DIRS for
+    # the start node (no previous move).  This lets A* distinguish
+    # reaching a cell from different directions and apply a turn penalty
+    # when the direction changes.
+    _NO_DIR = _N_DIRS  # sentinel for "no previous direction"
+
+    def _encode(gx: int, gy: int, li: int, di: int) -> int:
+        return ((gy * W + gx) * n_layers + li) * (_N_DIRS + 1) + di
 
-    start_id = _encode(sx, sy, start_layer_idx)
-    end_id = _encode(ex, ey, end_layer_idx)
+    # The goal is any state at (ex, ey, end_layer) regardless of direction.
+    # We check for the cell-level match inside the loop.
+    start_id = _encode(sx, sy, start_layer_idx, _NO_DIR)
 
-    g_score = {start_id: 0.0}
+    g_score: dict[int, float] = {start_id: 0.0}
     parent: dict[int, int | None] = {start_id: None}
     open_heap = [(_octile_dist(sx, sy, ex, ey), start_id)]
     closed: set[int] = set()
@@ -307,45 +328,55 @@ def grid_a_star(
         closed.add(cur_id)
         visited += 1
 
-        if cur_id == end_id:
+        # Decode state.
+        di = cur_id % (_N_DIRS + 1)
+        rest = cur_id // (_N_DIRS + 1)
+        li = rest % n_layers
+        rest2 = rest // n_layers
+        cy = rest2 // W
+        cx = rest2 % W
+        cur_g = g_score[cur_id]
+        cur_grid = grids[li]
+
+        # Goal check: any direction at the target cell on the target layer.
+        if cx == ex and cy == ey and li == end_layer_idx:
             path: list[tuple[float, float, int]] = []
-            nid = cur_id
+            nid: int | None = cur_id
             while nid is not None:
-                li = nid % n_layers
-                rest = nid // n_layers
-                gy_p = rest // W
-                gx_p = rest % W
+                rest_n = nid // (_N_DIRS + 1)
+                li_n = rest_n % n_layers
+                rest2_n = rest_n // n_layers
+                gy_p = rest2_n // W
+                gx_p = rest2_n % W
                 wx, wy = ref.to_world(gx_p, gy_p)
-                path.append((wx, wy, li))
+                path.append((wx, wy, li_n))
                 nid = parent[nid]
             path.reverse()
 
-            # Compute length from world-coordinate distance (ignore
-            # layer — via cost is already baked into g_score).
             total_len = 0.0
             for i in range(1, len(path)):
                 px, py, _ = path[i - 1]
-                cx, cy, _ = path[i]
-                total_len += math.hypot(cx - px, cy - py)
+                cx_p, cy_p, _ = path[i]
+                total_len += math.hypot(cx_p - px, cy_p - py)
             return AStarResult(path=path, cells_visited=visited, path_length_mm=total_len)
 
-        li = cur_id % n_layers
-        rest = cur_id // n_layers
-        cy = rest // W
-        cx = rest % W
-        cur_g = g_score[cur_id]
-        cur_grid = grids[li]
-
         # ---- Same-layer 8-dir moves ----
-        for dx, dy, is_diag in _DIRECTIONS:
+        for dir_idx, (dx, dy, is_diag) in enumerate(_DIRECTIONS):
             nx, ny = cx + dx, cy + dy
             if not cur_grid.is_free(nx, ny):
                 continue
-            nid = _encode(nx, ny, li)
+            nid = _encode(nx, ny, li, dir_idx)
             if nid in closed:
                 continue
             step = _DIAG_COST if is_diag else _CARD_COST
-            tentative = cur_g + step
+            # Turn penalty: if this move's direction differs from the
+            # arrival direction (and we have a previous direction), add
+            # the penalty.  45° changes (cardinal→diagonal) cost the
+            # same as 90° changes — both are one turn.
+            tp = 0.0
+            if turn_penalty > 0 and di != _NO_DIR and di != dir_idx:
+                tp = turn_penalty
+            tentative = cur_g + step + tp
             if tentative < g_score.get(nid, float("inf")):
                 g_score[nid] = tentative
                 heapq.heappush(
@@ -364,7 +395,8 @@ def grid_a_star(
                     wx, wy = ref.to_world(cx, cy)
                     if any(z.contains(Point(wx, wy)) for z in via_forbidden_zones):
                         continue
-                nid = _encode(cx, cy, tgt_li)
+                # Via resets direction (layer change is not a "turn").
+                nid = _encode(cx, cy, tgt_li, _NO_DIR)
                 if nid in closed:
                     continue
                 tentative = cur_g + via_cost
@@ -422,6 +454,7 @@ def hierarchical_a_star(
     end_world: tuple[float, float],
     fine_resolution: float = GRID_RESOLUTION,
     route_bbox: tuple[float, float, float, float] | None = None,
+    turn_penalty: float = _TURN_PENALTY,
 ) -> AStarResult:
     """Run hierarchical A* with auto-detection of single-pass vs two-pass.
 
@@ -457,11 +490,11 @@ def hierarchical_a_star(
 
     if fine_cells < _SINGLE_PASS_THRESHOLD:
         grid = build_grid_map(obstacles, bbox, resolution=fine_resolution)
-        return grid_a_star([grid], start_world, end_world)
+        return grid_a_star([grid], start_world, end_world, turn_penalty=turn_penalty)
 
     coarse_res = fine_resolution * COARSE_FACTOR
     coarse_grid = build_grid_map(obstacles, bbox, resolution=coarse_res)
-    coarse_result = grid_a_star([coarse_grid], start_world, end_world)
+    coarse_result = grid_a_star([coarse_grid], start_world, end_world, turn_penalty=turn_penalty)
     if coarse_result.path is None:
         return AStarResult(path=None, cells_visited=coarse_result.cells_visited)
 
@@ -477,7 +510,7 @@ def hierarchical_a_star(
     )
 
     fine_grid = build_grid_map(obstacles, band, resolution=fine_resolution)
-    result = grid_a_star([fine_grid], start_world, end_world)
+    result = grid_a_star([fine_grid], start_world, end_world, turn_penalty=turn_penalty)
     if result.path is not None:
         result.cells_visited += coarse_result.cells_visited
     else:
@@ -535,6 +568,7 @@ def multi_layer_a_star(
     fine_resolution: float = GRID_RESOLUTION,
     via_cost: float = _VIA_COST,
     via_forbidden_zones: list | None = None,
+    turn_penalty: float = _TURN_PENALTY,
 ) -> MultiLayerAStarResult:
     """Run A* across multiple copper layers.
 
@@ -583,6 +617,7 @@ def multi_layer_a_star(
         via_from=via_from or None,
         via_cost=via_cost,
         via_forbidden_zones=via_forbidden_zones,
+        turn_penalty=turn_penalty,
     )
     if result.path is None:
         return MultiLayerAStarResult(path=None, cells_visited=result.cells_visited)
@@ -683,6 +718,13 @@ def _grid_line_clear(
     return True
 
 
+def _is_45_family(x0: float, y0: float, x1: float, y1: float) -> bool:
+    """True when the segment (x0,y0)-(x1,y1) is axis-aligned or a 45° diagonal."""
+    dx = abs(x1 - x0)
+    dy = abs(y1 - y0)
+    return abs(dx) < 1e-6 or abs(dy) < 1e-6 or abs(dx - dy) < 1e-6
+
+
 def shortcut_path(
     pts: list[tuple[float, float]],
     obstacles: list,
@@ -693,16 +735,11 @@ def shortcut_path(
 
     Builds a walkability grid once, then for each point tries to skip
     as many subsequent points as possible while keeping the line clear.
-    Only 0°/45°/90°/135° shortcuts are accepted.
-
-    Args:
-        pts: Ordered ``(x, y)`` points (after collinear simplification).
-        obstacles: Inflated obstacle list (Polygon objects).
-        bbox: ``(min_x, min_y, max_x, max_y)`` of the route area.
-        resolution: Grid cell size in mm.
-
-    Returns:
-        Simplified polyline with redundant points removed.
+    Only 0°/45°/90°/135° shortcuts are accepted.  A shortcut that would
+    skip a direction change all the way through (producing a near-45°
+    long diagonal) is REJECTED: snapping that back to the 45° family
+    later would have to force a Manhattan corner (often a 90° turn), so
+    it is better to keep the original 45°+axis-aligned waypoints.
     """
     if len(pts) <= 2:
         return list(pts)
@@ -713,10 +750,13 @@ def shortcut_path(
     while i < len(pts) - 1:
         best_next = i + 1
         for k in range(len(pts) - 1, i, -1):
-            dx = pts[k][0] - result[-1][0]
-            dy = pts[k][1] - result[-1][1]
-            if abs(dx) > 1e-9 and abs(dy) > 1e-9 and abs(abs(dx) - abs(dy)) > 1e-9:
-                continue  # not 0/45/90/135°
+            if not _is_45_family(
+                result[-1][0],
+                result[-1][1],
+                pts[k][0],
+                pts[k][1],
+            ):
+                continue
             if _grid_line_clear(
                 grid,
                 result[-1][0],