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

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),