kicad-sch-api 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

kicad_sch_api/core/managers/wire.py

@@ -0,0 +1,346 @@
+"""
+Wire Manager for KiCAD schematic wire operations.
+
+Handles wire creation, removal, pin connections, and auto-routing functionality
+while managing component pin position calculations and connectivity analysis.
+"""
+
+import logging
+import uuid
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from ...library.cache import get_symbol_cache
+from ..types import Point, Wire, WireType
+from ..wires import WireCollection
+
+logger = logging.getLogger(__name__)
+
+
+class WireManager:
+    """
+    Manages wire operations and pin connectivity in KiCAD schematics.
+
+    Responsible for:
+    - Wire creation and removal
+    - Pin position calculations
+    - Auto-routing between pins
+    - Connectivity analysis
+    - Wire-to-pin connections
+    """
+
+    def __init__(
+        self, schematic_data: Dict[str, Any], wire_collection: WireCollection, component_collection
+    ):
+        """
+        Initialize WireManager.
+
+        Args:
+            schematic_data: Reference to schematic data
+            wire_collection: Wire collection for management
+            component_collection: Component collection for pin lookups
+        """
+        self._data = schematic_data
+        self._wires = wire_collection
+        self._components = component_collection
+        self._symbol_cache = get_symbol_cache()
+
+    def add_wire(
+        self, start: Union[Point, Tuple[float, float]], end: Union[Point, Tuple[float, float]]
+    ) -> str:
+        """
+        Add a wire connection.
+
+        Args:
+            start: Start point
+            end: End point
+
+        Returns:
+            UUID of created wire
+        """
+        if isinstance(start, tuple):
+            start = Point(start[0], start[1])
+        if isinstance(end, tuple):
+            end = Point(end[0], end[1])
+
+        # Use the wire collection to add the wire
+        wire_uuid = self._wires.add(start=start, end=end)
+
+        logger.debug(f"Added wire: {start} -> {end}")
+        return wire_uuid
+
+    def remove_wire(self, wire_uuid: str) -> bool:
+        """
+        Remove wire by UUID.
+
+        Args:
+            wire_uuid: UUID of wire to remove
+
+        Returns:
+            True if wire was removed, False if not found
+        """
+        # Remove from wire collection
+        removed_from_collection = self._wires.remove(wire_uuid)
+
+        # Also remove from data structure for consistency
+        wires = self._data.get("wires", [])
+        removed_from_data = False
+        for i, wire in enumerate(wires):
+            if wire.get("uuid") == wire_uuid:
+                del wires[i]
+                removed_from_data = True
+                break
+
+        success = removed_from_collection or removed_from_data
+        if success:
+            logger.debug(f"Removed wire: {wire_uuid}")
+
+        return success
+
+    def add_wire_to_pin(
+        self, start: Union[Point, Tuple[float, float]], component_ref: str, pin_number: str
+    ) -> str:
+        """
+        Add wire from a point to a component pin.
+
+        Args:
+            start: Starting point
+            component_ref: Component reference (e.g., "R1")
+            pin_number: Pin number on component
+
+        Returns:
+            UUID of created wire
+
+        Raises:
+            ValueError: If component or pin not found
+        """
+        pin_position = self.get_component_pin_position(component_ref, pin_number)
+        if pin_position is None:
+            raise ValueError(f"Pin {pin_number} not found on component {component_ref}")
+
+        return self.add_wire(start, pin_position)
+
+    def add_wire_between_pins(
+        self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
+    ) -> str:
+        """
+        Add wire between two component pins.
+
+        Args:
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
+
+        Returns:
+            UUID of created wire
+
+        Raises:
+            ValueError: If components or pins not found
+        """
+        pin1_pos = self.get_component_pin_position(component1_ref, pin1_number)
+        pin2_pos = self.get_component_pin_position(component2_ref, pin2_number)
+
+        if pin1_pos is None:
+            raise ValueError(f"Pin {pin1_number} not found on component {component1_ref}")
+        if pin2_pos is None:
+            raise ValueError(f"Pin {pin2_number} not found on component {component2_ref}")
+
+        return self.add_wire(pin1_pos, pin2_pos)
+
+    def get_component_pin_position(self, component_ref: str, pin_number: str) -> Optional[Point]:
+        """
+        Get absolute position of a component pin.
+
+        This consolidates the duplicate implementations in the original schematic class.
+
+        Args:
+            component_ref: Component reference (e.g., "R1")
+            pin_number: Pin number
+
+        Returns:
+            Absolute pin position or None if not found
+        """
+        # Find component
+        component = self._components.get(component_ref)
+        if not component:
+            logger.warning(f"Component not found: {component_ref}")
+            return None
+
+        # Get symbol definition from cache
+        symbol_def = self._symbol_cache.get_symbol(component.lib_id)
+        if not symbol_def:
+            logger.warning(f"Symbol definition not found: {component.lib_id}")
+            return None
+
+        # Find pin in symbol definition
+        for pin in symbol_def.pins:
+            if pin.number == pin_number:
+                # Calculate absolute position
+                # Apply component rotation/mirroring if needed (simplified for now)
+                absolute_x = component.position.x + pin.position.x
+                absolute_y = component.position.y + pin.position.y
+
+                return Point(absolute_x, absolute_y)
+
+        logger.warning(f"Pin {pin_number} not found on component {component_ref}")
+        return None
+
+    def list_component_pins(self, component_ref: str) -> List[Tuple[str, Point]]:
+        """
+        List all pins and their positions for a component.
+
+        Args:
+            component_ref: Component reference
+
+        Returns:
+            List of (pin_number, absolute_position) tuples
+        """
+        pins = []
+
+        # Find component
+        component = self._components.get(component_ref)
+        if not component:
+            return pins
+
+        # Get symbol definition
+        symbol_def = self._symbol_cache.get_symbol(component.lib_id)
+        if not symbol_def:
+            return pins
+
+        # Calculate absolute positions for all pins
+        for pin in symbol_def.pins:
+            absolute_x = component.position.x + pin.position.x
+            absolute_y = component.position.y + pin.position.y
+            pins.append((pin.number, Point(absolute_x, absolute_y)))
+
+        return pins
+
+    def auto_route_pins(
+        self,
+        component1_ref: str,
+        pin1_number: str,
+        component2_ref: str,
+        pin2_number: str,
+        routing_strategy: str = "direct",
+    ) -> List[str]:
+        """
+        Auto-route between two pins with different strategies.
+
+        Args:
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
+            routing_strategy: "direct" or "manhattan"
+
+        Returns:
+            List of wire UUIDs created
+
+        Raises:
+            ValueError: If components or pins not found
+        """
+        pin1_pos = self.get_component_pin_position(component1_ref, pin1_number)
+        pin2_pos = self.get_component_pin_position(component2_ref, pin2_number)
+
+        if pin1_pos is None:
+            raise ValueError(f"Pin {pin1_number} not found on component {component1_ref}")
+        if pin2_pos is None:
+            raise ValueError(f"Pin {pin2_number} not found on component {component2_ref}")
+
+        wire_uuids = []
+
+        if routing_strategy == "direct":
+            # Direct wire between pins
+            wire_uuid = self.add_wire(pin1_pos, pin2_pos)
+            wire_uuids.append(wire_uuid)
+
+        elif routing_strategy == "manhattan":
+            # Manhattan routing (L-shaped path)
+            # Route horizontally first, then vertically
+            intermediate_point = Point(pin2_pos.x, pin1_pos.y)
+
+            # Only add intermediate wire if it has length
+            if abs(pin1_pos.x - pin2_pos.x) > 0.1:  # Minimum wire length
+                wire1_uuid = self.add_wire(pin1_pos, intermediate_point)
+                wire_uuids.append(wire1_uuid)
+
+            if abs(pin1_pos.y - pin2_pos.y) > 0.1:  # Minimum wire length
+                wire2_uuid = self.add_wire(intermediate_point, pin2_pos)
+                wire_uuids.append(wire2_uuid)
+
+        else:
+            raise ValueError(f"Unknown routing strategy: {routing_strategy}")
+
+        logger.info(
+            f"Auto-routed {component1_ref}:{pin1_number} to {component2_ref}:{pin2_number} using {routing_strategy}"
+        )
+        return wire_uuids
+
+    def are_pins_connected(
+        self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
+    ) -> bool:
+        """
+        Check if two pins are connected via wires.
+
+        Args:
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
+
+        Returns:
+            True if pins are connected, False otherwise
+        """
+        pin1_pos = self.get_component_pin_position(component1_ref, pin1_number)
+        pin2_pos = self.get_component_pin_position(component2_ref, pin2_number)
+
+        if pin1_pos is None or pin2_pos is None:
+            return False
+
+        # Check for direct wire connection
+        for wire in self._wires:
+            if (wire.start == pin1_pos and wire.end == pin2_pos) or (
+                wire.start == pin2_pos and wire.end == pin1_pos
+            ):
+                return True
+
+        # TODO: Implement more sophisticated connectivity analysis
+        # This would involve following wire networks through junctions
+        return False
+
+    def connect_pins_with_wire(
+        self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
+    ) -> str:
+        """
+        Legacy alias for add_wire_between_pins.
+
+        Args:
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
+
+        Returns:
+            UUID of created wire
+        """
+        return self.add_wire_between_pins(component1_ref, pin1_number, component2_ref, pin2_number)
+
+    def get_wire_statistics(self) -> Dict[str, Any]:
+        """
+        Get statistics about wires in the schematic.
+
+        Returns:
+            Dictionary with wire statistics
+        """
+        total_wires = len(self._wires)
+        total_length = sum(wire.start.distance_to(wire.end) for wire in self._wires)
+
+        return {
+            "total_wires": total_wires,
+            "total_length": total_length,
+            "average_length": total_length / total_wires if total_wires > 0 else 0,
+            "wire_types": {
+                "normal": len([w for w in self._wires if w.wire_type == WireType.WIRE]),
+                "bus": len([w for w in self._wires if w.wire_type == WireType.BUS]),
+            },
+        }

kicad_sch_api/core/nets.py

@@ -307,4 +307,4 @@ class NetCollection:
 
     def __bool__(self) -> bool:
         """Return True if collection has nets."""
-        return len(self._nets) > 0
+        return len(self._nets) > 0

kicad_sch_api/core/no_connects.py

@@ -10,7 +10,7 @@ import uuid
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
 
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
-from .types import Point, NoConnect
+from .types import NoConnect, Point
 
 logger = logging.getLogger(__name__)
 
@@ -169,7 +169,9 @@ class NoConnectCollection:
         logger.debug(f"Removed no-connect: {no_connect_element}")
         return True
 
-    def find_at_position(self, position: Union[Point, Tuple[float, float]], tolerance: float = 0.1) -> List[NoConnectElement]:
+    def find_at_position(
+        self, position: Union[Point, Tuple[float, float]], tolerance: float = 0.1
+    ) -> List[NoConnectElement]:
         """
         Find no-connects at or near a position.
 
@@ -271,4 +273,4 @@ class NoConnectCollection:
 
     def __bool__(self) -> bool:
         """Return True if collection has no-connects."""
-        return len(self._no_connects) > 0
+        return len(self._no_connects) > 0

kicad_sch_api/core/parser.py

@@ -498,7 +498,7 @@ class SExpressionParser:
             "stroke_width": 0.0,
             "stroke_type": "default",
             "uuid": None,
-            "wire_type": "wire"  # Default to wire (vs bus)
+            "wire_type": "wire",  # Default to wire (vs bus)
         }
 
         for elem in item[1:]:
@@ -541,7 +541,7 @@ class SExpressionParser:
             "position": {"x": 0, "y": 0},
             "diameter": 0,
             "color": (0, 0, 0, 0),
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[1:]:
@@ -563,7 +563,12 @@ class SExpressionParser:
             elif elem_type == "color":
                 # Parse color: (color r g b a)
                 if len(elem) >= 5:
-                    junction_data["color"] = (int(elem[1]), int(elem[2]), int(elem[3]), int(elem[4]))
+                    junction_data["color"] = (
+                        int(elem[1]),
+                        int(elem[2]),
+                        int(elem[3]),
+                        int(elem[4]),
+                    )
 
             elif elem_type == "uuid":
                 junction_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
@@ -581,7 +586,7 @@ class SExpressionParser:
             "position": {"x": 0, "y": 0},
             "rotation": 0,
             "size": 1.27,
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[2:]:  # Skip label keyword and text
@@ -624,7 +629,7 @@ class SExpressionParser:
             "rotation": 0,
             "size": 1.27,
             "justify": "left",
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[2:]:  # Skip hierarchical_label keyword and text
@@ -649,7 +654,11 @@ class SExpressionParser:
                 # Parse effects for font size and justification: (effects (font (size x y)) (justify left))
                 for effect_elem in elem[1:]:
                     if isinstance(effect_elem, list):
-                        effect_type = str(effect_elem[0]) if isinstance(effect_elem[0], sexpdata.Symbol) else None
+                        effect_type = (
+                            str(effect_elem[0])
+                            if isinstance(effect_elem[0], sexpdata.Symbol)
+                            else None
+                        )
 
                         if effect_type == "font":
                             # Parse font size
@@ -671,10 +680,7 @@ class SExpressionParser:
     def _parse_no_connect(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a no_connect symbol."""
         # Format: (no_connect (at x y) (uuid ...))
-        no_connect_data = {
-            "position": {"x": 0, "y": 0},
-            "uuid": None
-        }
+        no_connect_data = {"position": {"x": 0, "y": 0}, "uuid": None}
 
         for elem in item[1:]:
             if not isinstance(elem, list):
@@ -702,7 +708,7 @@ class SExpressionParser:
             "position": {"x": 0, "y": 0},
             "rotation": 0,
             "size": 1.27,
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[2:]:
@@ -750,7 +756,7 @@ class SExpressionParser:
             "font_size": 1.27,
             "justify_horizontal": "left",
             "justify_vertical": "top",
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[2:]:
@@ -772,7 +778,12 @@ class SExpressionParser:
                     text_box_data["size"] = {"width": float(elem[1]), "height": float(elem[2])}
             elif elem_type == "margins":
                 if len(elem) >= 5:
-                    text_box_data["margins"] = (float(elem[1]), float(elem[2]), float(elem[3]), float(elem[4]))
+                    text_box_data["margins"] = (
+                        float(elem[1]),
+                        float(elem[2]),
+                        float(elem[3]),
+                        float(elem[4]),
+                    )
             elif elem_type == "stroke":
                 for stroke_elem in elem[1:]:
                     if isinstance(stroke_elem, list):
@@ -784,7 +795,9 @@ class SExpressionParser:
             elif elem_type == "fill":
                 for fill_elem in elem[1:]:
                     if isinstance(fill_elem, list) and str(fill_elem[0]) == "type":
-                        text_box_data["fill_type"] = str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        text_box_data["fill_type"] = (
+                            str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        )
             elif elem_type == "effects":
                 for effect_elem in elem[1:]:
                     if isinstance(effect_elem, list):
@@ -823,7 +836,7 @@ class SExpressionParser:
             "filename": "sheet.kicad_sch",
             "pins": [],
             "project_name": "",
-            "page_number": "2"
+            "page_number": "2",
         }
 
         for elem in item[1:]:
@@ -860,7 +873,12 @@ class SExpressionParser:
                 for fill_elem in elem[1:]:
                     if isinstance(fill_elem, list) and str(fill_elem[0]) == "color":
                         if len(fill_elem) >= 5:
-                            sheet_data["fill_color"] = (int(fill_elem[1]), int(fill_elem[2]), int(fill_elem[3]), float(fill_elem[4]))
+                            sheet_data["fill_color"] = (
+                                int(fill_elem[1]),
+                                int(fill_elem[2]),
+                                int(fill_elem[3]),
+                                float(fill_elem[4]),
+                            )
             elif elem_type == "uuid":
                 sheet_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
             elif elem_type == "property":
@@ -886,7 +904,9 @@ class SExpressionParser:
                             if isinstance(path_elem, list) and str(path_elem[0]) == "path":
                                 for page_elem in path_elem[1:]:
                                     if isinstance(page_elem, list) and str(page_elem[0]) == "page":
-                                        sheet_data["page_number"] = str(page_elem[1]) if len(page_elem) > 1 else "2"
+                                        sheet_data["page_number"] = (
+                                            str(page_elem[1]) if len(page_elem) > 1 else "2"
+                                        )
 
         return sheet_data
 
@@ -903,7 +923,7 @@ class SExpressionParser:
             "rotation": 0,
             "size": 1.27,
             "justify": "right",
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[3:]:
@@ -937,12 +957,7 @@ class SExpressionParser:
     def _parse_polyline(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a polyline graphical element."""
         # Format: (polyline (pts (xy x1 y1) (xy x2 y2) ...) (stroke ...) (uuid ...))
-        polyline_data = {
-            "points": [],
-            "stroke_width": 0,
-            "stroke_type": "default",
-            "uuid": None
-        }
+        polyline_data = {"points": [], "stroke_width": 0, "stroke_type": "default", "uuid": None}
 
         for elem in item[1:]:
             if not isinstance(elem, list):
@@ -977,7 +992,7 @@ class SExpressionParser:
             "stroke_width": 0,
             "stroke_type": "default",
             "fill_type": "none",
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[1:]:
@@ -1018,7 +1033,7 @@ class SExpressionParser:
             "stroke_width": 0,
             "stroke_type": "default",
             "fill_type": "none",
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[1:]:
@@ -1042,7 +1057,9 @@ class SExpressionParser:
             elif elem_type == "fill":
                 for fill_elem in elem[1:]:
                     if isinstance(fill_elem, list) and str(fill_elem[0]) == "type":
-                        circle_data["fill_type"] = str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        circle_data["fill_type"] = (
+                            str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        )
             elif elem_type == "uuid":
                 circle_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
 
@@ -1056,7 +1073,7 @@ class SExpressionParser:
             "stroke_width": 0,
             "stroke_type": "default",
             "fill_type": "none",
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in item[1:]:
@@ -1080,7 +1097,9 @@ class SExpressionParser:
             elif elem_type == "fill":
                 for fill_elem in elem[1:]:
                     if isinstance(fill_elem, list) and str(fill_elem[0]) == "type":
-                        bezier_data["fill_type"] = str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        bezier_data["fill_type"] = (
+                            str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        )
             elif elem_type == "uuid":
                 bezier_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
 
@@ -1111,7 +1130,9 @@ class SExpressionParser:
             elif elem_type == "fill":
                 for fill_elem in elem[1:]:
                     if isinstance(fill_elem, list) and str(fill_elem[0]) == "type":
-                        rectangle["fill_type"] = str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        rectangle["fill_type"] = (
+                            str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+                        )
             elif elem_type == "uuid" and len(elem) >= 2:
                 rectangle["uuid"] = str(elem[1])
 
@@ -1120,12 +1141,7 @@ class SExpressionParser:
     def _parse_image(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse an image element."""
         # Format: (image (at x y) (uuid "...") (data "base64..."))
-        image = {
-            "position": {"x": 0, "y": 0},
-            "data": "",
-            "scale": 1.0,
-            "uuid": None
-        }
+        image = {"position": {"x": 0, "y": 0}, "data": "", "scale": 1.0, "uuid": None}
 
         for elem in item[1:]:
             if not isinstance(elem, list):
@@ -1264,14 +1280,24 @@ class SExpressionParser:
         if hierarchy_path:
             # Use the full hierarchical path (includes root + all sheet symbols)
             instance_path = hierarchy_path
-            logger.debug(f"🔧 Using FULL hierarchy_path: {instance_path} for component {symbol_data.get('reference', 'unknown')}")
+            logger.debug(
+                f"🔧 Using FULL hierarchy_path: {instance_path} for component {symbol_data.get('reference', 'unknown')}"
+            )
         else:
             # Fallback: use root_uuid or schematic_uuid for flat designs
-            root_uuid = symbol_data.get("properties", {}).get("root_uuid") or schematic_uuid or str(uuid.uuid4())
+            root_uuid = (
+                symbol_data.get("properties", {}).get("root_uuid")
+                or schematic_uuid
+                or str(uuid.uuid4())
+            )
             instance_path = f"/{root_uuid}"
-            logger.debug(f"🔧 Using root UUID path: {instance_path} for component {symbol_data.get('reference', 'unknown')}")
+            logger.debug(
+                f"🔧 Using root UUID path: {instance_path} for component {symbol_data.get('reference', 'unknown')}"
+            )
 
-        logger.debug(f"🔧 Component properties keys: {list(symbol_data.get('properties', {}).keys())}")
+        logger.debug(
+            f"🔧 Component properties keys: {list(symbol_data.get('properties', {}).keys())}"
+        )
         logger.debug(f"🔧 Using project name: '{project_name}'")
 
         sexp.append(
@@ -1959,12 +1985,20 @@ class SExpressionParser:
         stroke_sexp = [sexpdata.Symbol("stroke")]
         stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
         stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(stroke_type)])
+        # Add stroke color if present
+        if "stroke_color" in rectangle_data:
+            r, g, b, a = rectangle_data["stroke_color"]
+            stroke_sexp.append([sexpdata.Symbol("color"), r, g, b, a])
         sexp.append(stroke_sexp)
 
         # Add fill
         fill_type = rectangle_data.get("fill_type", "none")
         fill_sexp = [sexpdata.Symbol("fill")]
         fill_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(fill_type)])
+        # Add fill color if present
+        if "fill_color" in rectangle_data:
+            r, g, b, a = rectangle_data["fill_color"]
+            fill_sexp.append([sexpdata.Symbol("color"), r, g, b, a])
         sexp.append(fill_sexp)
 
         # Add UUID
@@ -2000,7 +2034,7 @@ class SExpressionParser:
             # Split the data into 76-character chunks
             chunk_size = 76
             for i in range(0, len(data), chunk_size):
-                data_sexp.append(data[i:i+chunk_size])
+                data_sexp.append(data[i : i + chunk_size])
             sexp.append(data_sexp)
 
         return sexp