kicad-sch-api 0.4.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

kicad_sch_api/core/managers/sheet.py

@@ -11,11 +11,12 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from ..types import Point
+from .base import BaseManager
 
 logger = logging.getLogger(__name__)
 
 
-class SheetManager:
+class SheetManager(BaseManager):
     """
     Manages hierarchical sheets and multi-sheet project coordination.
 
@@ -34,7 +35,7 @@ class SheetManager:
         Args:
             schematic_data: Reference to schematic data
         """
-        self._data = schematic_data
+        super().__init__(schematic_data)
 
     def add_sheet(
         self,
@@ -121,29 +122,30 @@ class SheetManager:
         sheet_uuid: str,
         name: str,
         pin_type: str,
-        position: Union[Point, Tuple[float, float]],
-        rotation: float = 0,
-        justify: str = "left",
+        edge: str,
+        position_along_edge: float,
         uuid_str: Optional[str] = None,
     ) -> Optional[str]:
         """
-        Add a pin to an existing sheet.
+        Add a pin to an existing sheet using edge-based positioning.
 
         Args:
             sheet_uuid: UUID of target sheet
             name: Pin name
             pin_type: Pin type (input, output, bidirectional, tri_state, passive)
-            position: Pin position relative to sheet
-            rotation: Pin rotation in degrees
-            justify: Text justification (left, right, center)
+            edge: Edge to place pin on ("right", "bottom", "left", "top")
+            position_along_edge: Distance along edge from reference corner (mm)
             uuid_str: Optional pin UUID
 
         Returns:
             UUID of created pin, or None if sheet not found
-        """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
 
+        Edge positioning (clockwise from right):
+            - "right": rotation=0°, justify="right", position from top edge
+            - "bottom": rotation=270°, justify="left", position from left edge
+            - "left": rotation=180°, justify="left", position from bottom edge
+            - "top": rotation=90°, justify="right", position from left edge
+        """
         if uuid_str is None:
             uuid_str = str(uuid.uuid4())
 
@@ -152,15 +154,49 @@ class SheetManager:
             logger.warning(f"Invalid sheet pin type: {pin_type}. Using 'input'")
             pin_type = "input"
 
+        valid_edges = ["right", "bottom", "left", "top"]
+        if edge not in valid_edges:
+            logger.error(f"Invalid edge: {edge}. Must be one of {valid_edges}")
+            return None
+
         # Find the sheet
         sheets = self._data.get("sheets", [])
         for sheet in sheets:
             if sheet.get("uuid") == sheet_uuid:
+                # Get sheet bounds
+                sheet_x = sheet["position"]["x"]
+                sheet_y = sheet["position"]["y"]
+                sheet_width = sheet["size"]["width"]
+                sheet_height = sheet["size"]["height"]
+
+                # Calculate position, rotation, and justification based on edge
+                # Clockwise: right (0°) → bottom (270°) → left (180°) → top (90°)
+                if edge == "right":
+                    x = sheet_x + sheet_width
+                    y = sheet_y + position_along_edge
+                    rotation = 0
+                    justify = "right"
+                elif edge == "bottom":
+                    x = sheet_x + position_along_edge
+                    y = sheet_y + sheet_height
+                    rotation = 270
+                    justify = "left"
+                elif edge == "left":
+                    x = sheet_x
+                    y = sheet_y + sheet_height - position_along_edge
+                    rotation = 180
+                    justify = "left"
+                elif edge == "top":
+                    x = sheet_x + position_along_edge
+                    y = sheet_y
+                    rotation = 90
+                    justify = "right"
+
                 pin_data = {
                     "uuid": uuid_str,
                     "name": name,
                     "pin_type": pin_type,
-                    "position": {"x": position.x, "y": position.y},
+                    "position": {"x": x, "y": y},
                     "rotation": rotation,
                     "size": 1.27,
                     "justify": justify,
@@ -169,7 +205,9 @@ class SheetManager:
                 # Add to sheet's pins array (already initialized in add_sheet)
                 sheet["pins"].append(pin_data)
 
-                logger.debug(f"Added pin '{name}' to sheet {sheet_uuid}")
+                logger.debug(
+                    f"Added pin '{name}' to sheet {sheet_uuid} on {edge} edge at ({x}, {y})"
+                )
                 return uuid_str
 
         logger.warning(f"Sheet not found: {sheet_uuid}")

kicad_sch_api/core/managers/text_elements.py

@@ -11,11 +11,12 @@ import uuid
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from ..types import Point
+from .base import BaseManager
 
 logger = logging.getLogger(__name__)
 
 
-class TextElementManager:
+class TextElementManager(BaseManager):
     """
     Manages text elements and labeling in KiCAD schematics.
 
@@ -34,7 +35,7 @@ class TextElementManager:
         Args:
             schematic_data: Reference to schematic data
         """
-        self._data = schematic_data
+        super().__init__(schematic_data)
 
     def add_label(
         self,

kicad_sch_api/core/managers/validation.py

@@ -11,11 +11,12 @@ from typing import Any, Dict, List, Optional, Set, Tuple
 
 from ...utils.validation import ValidationError, ValidationIssue
 from ..types import Point
+from .base import BaseManager
 
 logger = logging.getLogger(__name__)
 
 
-class ValidationManager:
+class ValidationManager(BaseManager):
     """
     Comprehensive validation manager for schematic integrity.
 
@@ -39,7 +40,7 @@ class ValidationManager:
             component_collection: Component collection for validation
             wire_collection: Wire collection for connectivity analysis
         """
-        self._data = schematic_data
+        super().__init__(schematic_data)
         self._components = component_collection
         self._wires = wire_collection
         self._validation_rules = self._initialize_validation_rules()

kicad_sch_api/core/managers/wire.py

@@ -10,13 +10,15 @@ import uuid
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from ...library.cache import get_symbol_cache
+from ..connectivity import ConnectivityAnalyzer, Net
 from ..types import Point, Wire, WireType
 from ..wires import WireCollection
+from .base import BaseManager
 
 logger = logging.getLogger(__name__)
 
 
-class WireManager:
+class WireManager(BaseManager):
     """
     Manages wire operations and pin connectivity in KiCAD schematics.
 
@@ -29,7 +31,11 @@ class WireManager:
     """
 
     def __init__(
-        self, schematic_data: Dict[str, Any], wire_collection: WireCollection, component_collection
+        self,
+        schematic_data: Dict[str, Any],
+        wire_collection: WireCollection,
+        component_collection,
+        schematic,
     ):
         """
         Initialize WireManager.
@@ -38,12 +44,18 @@ class WireManager:
             schematic_data: Reference to schematic data
             wire_collection: Wire collection for management
             component_collection: Component collection for pin lookups
+            schematic: Reference to parent Schematic object for connectivity analysis
         """
-        self._data = schematic_data
+        super().__init__(schematic_data)
         self._wires = wire_collection
         self._components = component_collection
+        self._schematic = schematic
         self._symbol_cache = get_symbol_cache()
 
+        # Lazy-initialized connectivity analyzer (always hierarchical)
+        self._connectivity_analyzer: Optional[ConnectivityAnalyzer] = None
+        self._connectivity_valid = False
+
     def add_wire(
         self, start: Union[Point, Tuple[float, float]], end: Union[Point, Tuple[float, float]]
     ) -> str:
@@ -65,6 +77,9 @@ class WireManager:
         # Use the wire collection to add the wire
         wire_uuid = self._wires.add(start=start, end=end)
 
+        # Invalidate connectivity cache
+        self._invalidate_connectivity()
+
         logger.debug(f"Added wire: {start} -> {end}")
         return wire_uuid
 
@@ -92,6 +107,8 @@ class WireManager:
 
         success = removed_from_collection or removed_from_data
         if success:
+            # Invalidate connectivity cache
+            self._invalidate_connectivity()
             logger.debug(f"Removed wire: {wire_uuid}")
 
         return success
@@ -151,7 +168,8 @@ class WireManager:
         """
         Get absolute position of a component pin.
 
-        This consolidates the duplicate implementations in the original schematic class.
+        Uses the same geometry transformation as the connectivity analyzer
+        to ensure consistent pin positions.
 
         Args:
             component_ref: Component reference (e.g., "R1")
@@ -160,27 +178,20 @@ class WireManager:
         Returns:
             Absolute pin position or None if not found
         """
+        from ..pin_utils import list_component_pins
+
         # 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
+        # Use pin_utils to get correct transformed positions
+        pins = list_component_pins(component)
 
-                return Point(absolute_x, absolute_y)
+        for pin_num, pin_pos in pins:
+            if pin_num == pin_number:
+                return pin_pos
 
         logger.warning(f"Pin {pin_number} not found on component {component_ref}")
         return None
@@ -189,31 +200,24 @@ class WireManager:
         """
         List all pins and their positions for a component.
 
+        Uses the same geometry transformation as the connectivity analyzer
+        to ensure consistent pin positions.
+
         Args:
             component_ref: Component reference
 
         Returns:
             List of (pin_number, absolute_position) tuples
         """
-        pins = []
+        from ..pin_utils import list_component_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 []
 
-        return pins
+        # Use pin_utils to get correct transformed positions
+        return list_component_pins(component)
 
     def auto_route_pins(
         self,
@@ -280,7 +284,14 @@ class WireManager:
         self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
     ) -> bool:
         """
-        Check if two pins are connected via wires.
+        Check if two pins are electrically connected.
+
+        Performs full connectivity analysis including:
+        - Direct wire connections
+        - Connections through junctions
+        - Connections through labels (local/global/hierarchical)
+        - Connections through power symbols
+        - Hierarchical sheet connections
 
         Args:
             component1_ref: First component reference
@@ -289,29 +300,15 @@ class WireManager:
             pin2_number: Second component pin number
 
         Returns:
-            True if pins are connected, False otherwise
+            True if pins are electrically 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)
+        self._ensure_connectivity()
+
+        if self._connectivity_analyzer:
+            return self._connectivity_analyzer.are_connected(
+                component1_ref, pin1_number, 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
-        # NOTE: Current implementation only checks for direct wire connections between pins.
-        # A full implementation would:
-        # 1. Follow wire networks through junctions (connection points)
-        # 2. Trace through labels (global/hierarchical net connections)
-        # 3. Build a complete net connectivity graph
-        # This is a known limitation - use ValidationManager for full electrical rule checking.
-        # Priority: MEDIUM - Would enable better automated wiring validation
         return False
 
     def connect_pins_with_wire(
@@ -350,3 +347,64 @@ class WireManager:
                 "bus": len([w for w in self._wires if w.wire_type == WireType.BUS]),
             },
         }
+
+    def get_net_for_pin(self, component_ref: str, pin_number: str) -> Optional[Net]:
+        """
+        Get the electrical net connected to a specific pin.
+
+        Args:
+            component_ref: Component reference (e.g., "R1")
+            pin_number: Pin number
+
+        Returns:
+            Net object if pin is connected, None otherwise
+        """
+        self._ensure_connectivity()
+
+        if self._connectivity_analyzer:
+            return self._connectivity_analyzer.get_net_for_pin(component_ref, pin_number)
+
+        return None
+
+    def get_connected_pins(self, component_ref: str, pin_number: str) -> List[Tuple[str, str]]:
+        """
+        Get all pins electrically connected to a specific pin.
+
+        Args:
+            component_ref: Component reference (e.g., "R1")
+            pin_number: Pin number
+
+        Returns:
+            List of (reference, pin_number) tuples for all connected pins
+        """
+        self._ensure_connectivity()
+
+        if self._connectivity_analyzer:
+            return self._connectivity_analyzer.get_connected_pins(component_ref, pin_number)
+
+        return []
+
+    def _ensure_connectivity(self):
+        """
+        Ensure connectivity analysis is up-to-date.
+
+        Lazily initializes and runs connectivity analyzer on first query.
+        Re-runs analysis if schematic has changed since last analysis.
+        """
+        if not self._connectivity_valid:
+            logger.debug("Running connectivity analysis (hierarchical)...")
+            self._connectivity_analyzer = ConnectivityAnalyzer()
+            self._connectivity_analyzer.analyze(self._schematic, hierarchical=True)
+            self._connectivity_valid = True
+            logger.debug("Connectivity analysis complete")
+
+    def _invalidate_connectivity(self):
+        """
+        Invalidate connectivity cache.
+
+        Called when schematic changes that affect connectivity (wires, components, etc.).
+        Next connectivity query will trigger re-analysis.
+        """
+        if self._connectivity_valid:
+            logger.debug("Invalidating connectivity cache")
+            self._connectivity_valid = False

kicad_sch_api/core/parsing_utils.py

@@ -0,0 +1,63 @@
+"""
+Utility functions for parsing S-expression data.
+
+This module contains helper functions used by various parsers
+to handle common parsing patterns safely and consistently.
+"""
+
+import logging
+from typing import Any
+
+import sexpdata
+
+logger = logging.getLogger(__name__)
+
+
+def parse_bool_property(value: Any, default: bool = True) -> bool:
+    """
+    Parse a boolean property from S-expression data.
+
+    Handles both sexpdata.Symbol and string types, converting yes/no to bool.
+    This is the canonical way to parse boolean properties from KiCad files.
+
+    Args:
+        value: Value from S-expression (Symbol, str, bool, or None)
+        default: Default value if parsing fails or value is None
+
+    Returns:
+        bool: Parsed boolean value
+
+    Examples:
+        >>> parse_bool_property(sexpdata.Symbol('yes'))
+        True
+        >>> parse_bool_property('no')
+        False
+        >>> parse_bool_property(None, default=False)
+        False
+        >>> parse_bool_property('YES')  # Case insensitive
+        True
+
+    Note:
+        This function was added to fix a critical bug where Symbol('yes') == 'yes'
+        returned False, causing properties like in_bom and on_board to be parsed
+        incorrectly.
+    """
+    # If value is None, use default
+    if value is None:
+        return default
+
+    # Convert Symbol to string
+    if isinstance(value, sexpdata.Symbol):
+        value = str(value)
+
+    # Handle string values (case-insensitive)
+    if isinstance(value, str):
+        return value.lower() == "yes"
+
+    # Handle boolean values directly
+    if isinstance(value, bool):
+        return value
+
+    # Unexpected type - use default
+    logger.warning(f"Unexpected type for boolean property: {type(value)}, using default={default}")
+    return default

kicad_sch_api/core/pin_utils.py

@@ -66,14 +66,14 @@ def get_component_pin_position(component: SchematicSymbol, pin_number: str) -> O
 
         # Look for pin in symbol definition
         pins_found = []
-        for pin_def in symbol_def.get("pins", []):
-            pins_found.append(pin_def.get("number", "unknown"))
-            if pin_def.get("number") == pin_number:
+        for pin_def in symbol_def.pins:
+            pins_found.append(pin_def.number)
+            if pin_def.number == pin_number:
                 logger.info(f"  Found pin {pin_number} in symbol definition")
 
                 # Get pin position from definition
-                pin_x = pin_def.get("x", 0)
-                pin_y = pin_def.get("y", 0)
+                pin_x = pin_def.position.x
+                pin_y = pin_def.position.y
                 logger.info(f"  Symbol pin position: ({pin_x}, {pin_y})")
 
                 # Apply component transformations
@@ -96,6 +96,100 @@ def get_component_pin_position(component: SchematicSymbol, pin_number: str) -> O
     return None
 
 
+def get_component_pin_info(
+    component: SchematicSymbol, pin_number: str
+) -> Optional[Tuple[Point, float]]:
+    """
+    Get the absolute position and rotation of a component pin.
+
+    Args:
+        component: Component containing the pin
+        pin_number: Pin number to find
+
+    Returns:
+        Tuple of (absolute_position, absolute_rotation_degrees), or None if not found
+    """
+    logger.info(f"Getting pin info for {component.reference} pin {pin_number}")
+    logger.info(f"  Component position: ({component.position.x}, {component.position.y})")
+    component_rotation = getattr(component, "rotation", 0)
+    logger.info(f"  Component rotation: {component_rotation}°")
+    logger.info(f"  Component mirror: {getattr(component, 'mirror', None)}")
+
+    # First check if pin is already in component data
+    for pin in component.pins:
+        if pin.number == pin_number:
+            logger.info(f"  Found pin {pin_number} in component data")
+            logger.info(f"  Pin relative position: ({pin.position.x}, {pin.position.y})")
+            logger.info(f"  Pin rotation: {pin.rotation}°")
+
+            # Apply component transformations to position
+            absolute_pos = apply_transformation(
+                (pin.position.x, pin.position.y),
+                component.position,
+                component_rotation,
+                getattr(component, "mirror", None),
+            )
+
+            # Calculate absolute rotation (pin rotation + component rotation)
+            absolute_rotation = (pin.rotation + component_rotation) % 360
+
+            result_pos = Point(absolute_pos[0], absolute_pos[1])
+            logger.info(
+                f"  Final absolute position: ({result_pos.x}, {result_pos.y}), rotation: {absolute_rotation}°"
+            )
+            return (result_pos, absolute_rotation)
+
+    # If not in component data, try to get from symbol library
+    logger.info(f"  Pin {pin_number} not in component data, checking symbol library")
+
+    try:
+        symbol_cache = get_symbol_cache()
+        symbol_def = symbol_cache.get_symbol(component.lib_id)
+
+        if not symbol_def:
+            logger.warning(f"  Symbol definition not found for {component.lib_id}")
+            return None
+
+        logger.info(f"  Found symbol definition for {component.lib_id}")
+
+        # Look for pin in symbol definition
+        pins_found = []
+        for pin_def in symbol_def.pins:
+            pins_found.append(pin_def.number)
+            if pin_def.number == pin_number:
+                logger.info(f"  Found pin {pin_number} in symbol definition")
+
+                # Get pin position and rotation from definition
+                pin_x = pin_def.position.x
+                pin_y = pin_def.position.y
+                pin_rotation = pin_def.rotation
+                logger.info(f"  Symbol pin position: ({pin_x}, {pin_y}), rotation: {pin_rotation}°")
+
+                # Apply component transformations to position
+                absolute_pos = apply_transformation(
+                    (pin_x, pin_y),
+                    component.position,
+                    component_rotation,
+                    getattr(component, "mirror", None),
+                )
+
+                # Calculate absolute rotation
+                absolute_rotation = (pin_rotation + component_rotation) % 360
+
+                result_pos = Point(absolute_pos[0], absolute_pos[1])
+                logger.info(
+                    f"  Final absolute position: ({result_pos.x}, {result_pos.y}), rotation: {absolute_rotation}°"
+                )
+                return (result_pos, absolute_rotation)
+
+        logger.warning(f"  Pin {pin_number} not found in symbol. Available pins: {pins_found}")
+
+    except Exception as e:
+        logger.error(f"  Error accessing symbol cache: {e}")
+
+    return None
+
+
 def list_component_pins(component: SchematicSymbol) -> List[Tuple[str, Point]]:
     """
     List all pins for a component with their absolute positions.
@@ -127,10 +221,10 @@ def list_component_pins(component: SchematicSymbol) -> List[Tuple[str, Point]]:
             symbol_def = symbol_cache.get_symbol(component.lib_id)
 
             if symbol_def:
-                for pin_def in symbol_def.get("pins", []):
-                    pin_number = pin_def.get("number")
-                    pin_x = pin_def.get("x", 0)
-                    pin_y = pin_def.get("y", 0)
+                for pin_def in symbol_def.pins:
+                    pin_number = pin_def.number
+                    pin_x = pin_def.position.x
+                    pin_y = pin_def.position.y
 
                     absolute_pos = apply_transformation(
                         (pin_x, pin_y),