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

kicad_sch_api/core/no_connects.py

@@ -0,0 +1,276 @@
+"""
+No-connect element management for KiCAD schematics.
+
+This module provides collection classes for managing no-connect elements,
+featuring fast lookup, bulk operations, and validation.
+"""
+
+import logging
+import uuid
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
+
+from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
+from .types import NoConnect, Point
+
+logger = logging.getLogger(__name__)
+
+
+class NoConnectElement:
+    """
+    Enhanced wrapper for schematic no-connect elements with modern API.
+
+    Provides intuitive access to no-connect properties and operations
+    while maintaining exact format preservation.
+    """
+
+    def __init__(self, no_connect_data: NoConnect, parent_collection: "NoConnectCollection"):
+        """
+        Initialize no-connect element wrapper.
+
+        Args:
+            no_connect_data: Underlying no-connect data
+            parent_collection: Parent collection for updates
+        """
+        self._data = no_connect_data
+        self._collection = parent_collection
+        self._validator = SchematicValidator()
+
+    # Core properties with validation
+    @property
+    def uuid(self) -> str:
+        """No-connect element UUID."""
+        return self._data.uuid
+
+    @property
+    def position(self) -> Point:
+        """No-connect position."""
+        return self._data.position
+
+    @position.setter
+    def position(self, value: Union[Point, Tuple[float, float]]):
+        """Set no-connect position."""
+        if isinstance(value, tuple):
+            value = Point(value[0], value[1])
+        elif not isinstance(value, Point):
+            raise ValidationError(f"Position must be Point or tuple, got {type(value)}")
+        self._data.position = value
+        self._collection._mark_modified()
+
+    def validate(self) -> List[ValidationIssue]:
+        """Validate this no-connect element."""
+        return self._validator.validate_no_connect(self._data.__dict__)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert no-connect element to dictionary representation."""
+        return {
+            "uuid": self.uuid,
+            "position": {"x": self.position.x, "y": self.position.y},
+        }
+
+    def __str__(self) -> str:
+        """String representation."""
+        return f"<NoConnect @ {self.position}>"
+
+
+class NoConnectCollection:
+    """
+    Collection class for efficient no-connect element management.
+
+    Provides fast lookup, filtering, and bulk operations for schematic no-connect elements.
+    """
+
+    def __init__(self, no_connects: List[NoConnect] = None):
+        """
+        Initialize no-connect collection.
+
+        Args:
+            no_connects: Initial list of no-connect data
+        """
+        self._no_connects: List[NoConnectElement] = []
+        self._uuid_index: Dict[str, NoConnectElement] = {}
+        self._position_index: Dict[Tuple[float, float], List[NoConnectElement]] = {}
+        self._modified = False
+
+        # Add initial no-connects
+        if no_connects:
+            for no_connect_data in no_connects:
+                self._add_to_indexes(NoConnectElement(no_connect_data, self))
+
+        logger.debug(f"NoConnectCollection initialized with {len(self._no_connects)} no-connects")
+
+    def add(
+        self,
+        position: Union[Point, Tuple[float, float]],
+        no_connect_uuid: Optional[str] = None,
+    ) -> NoConnectElement:
+        """
+        Add a new no-connect element to the schematic.
+
+        Args:
+            position: No-connect position
+            no_connect_uuid: Specific UUID for no-connect (auto-generated if None)
+
+        Returns:
+            Newly created NoConnectElement
+
+        Raises:
+            ValidationError: If no-connect data is invalid
+        """
+        # Validate inputs
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+        elif not isinstance(position, Point):
+            raise ValidationError(f"Position must be Point or tuple, got {type(position)}")
+
+        # Generate UUID if not provided
+        if not no_connect_uuid:
+            no_connect_uuid = str(uuid.uuid4())
+
+        # Check for duplicate UUID
+        if no_connect_uuid in self._uuid_index:
+            raise ValidationError(f"NoConnect UUID {no_connect_uuid} already exists")
+
+        # Create no-connect data
+        no_connect_data = NoConnect(
+            uuid=no_connect_uuid,
+            position=position,
+        )
+
+        # Create wrapper and add to collection
+        no_connect_element = NoConnectElement(no_connect_data, self)
+        self._add_to_indexes(no_connect_element)
+        self._mark_modified()
+
+        logger.debug(f"Added no-connect: {no_connect_element}")
+        return no_connect_element
+
+    def get(self, no_connect_uuid: str) -> Optional[NoConnectElement]:
+        """Get no-connect by UUID."""
+        return self._uuid_index.get(no_connect_uuid)
+
+    def remove(self, no_connect_uuid: str) -> bool:
+        """
+        Remove no-connect by UUID.
+
+        Args:
+            no_connect_uuid: UUID of no-connect to remove
+
+        Returns:
+            True if no-connect was removed, False if not found
+        """
+        no_connect_element = self._uuid_index.get(no_connect_uuid)
+        if not no_connect_element:
+            return False
+
+        # Remove from indexes
+        self._remove_from_indexes(no_connect_element)
+        self._mark_modified()
+
+        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]:
+        """
+        Find no-connects at or near a position.
+
+        Args:
+            position: Position to search around
+            tolerance: Search tolerance in mm
+
+        Returns:
+            List of matching no-connect elements
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        matches = []
+        for no_connect_element in self._no_connects:
+            distance = no_connect_element.position.distance_to(position)
+            if distance <= tolerance:
+                matches.append(no_connect_element)
+        return matches
+
+    def filter(self, predicate: Callable[[NoConnectElement], bool]) -> List[NoConnectElement]:
+        """
+        Filter no-connects by predicate function.
+
+        Args:
+            predicate: Function that returns True for no-connects to include
+
+        Returns:
+            List of no-connects matching predicate
+        """
+        return [no_connect for no_connect in self._no_connects if predicate(no_connect)]
+
+    def bulk_update(self, criteria: Callable[[NoConnectElement], bool], updates: Dict[str, Any]):
+        """
+        Update multiple no-connects matching criteria.
+
+        Args:
+            criteria: Function to select no-connects to update
+            updates: Dictionary of property updates
+        """
+        updated_count = 0
+        for no_connect_element in self._no_connects:
+            if criteria(no_connect_element):
+                for prop, value in updates.items():
+                    if hasattr(no_connect_element, prop):
+                        setattr(no_connect_element, prop, value)
+                        updated_count += 1
+
+        if updated_count > 0:
+            self._mark_modified()
+            logger.debug(f"Bulk updated {updated_count} no-connect properties")
+
+    def clear(self):
+        """Remove all no-connects from collection."""
+        self._no_connects.clear()
+        self._uuid_index.clear()
+        self._position_index.clear()
+        self._mark_modified()
+
+    def _add_to_indexes(self, no_connect_element: NoConnectElement):
+        """Add no-connect to internal indexes."""
+        self._no_connects.append(no_connect_element)
+        self._uuid_index[no_connect_element.uuid] = no_connect_element
+
+        # Add to position index
+        pos_key = (no_connect_element.position.x, no_connect_element.position.y)
+        if pos_key not in self._position_index:
+            self._position_index[pos_key] = []
+        self._position_index[pos_key].append(no_connect_element)
+
+    def _remove_from_indexes(self, no_connect_element: NoConnectElement):
+        """Remove no-connect from internal indexes."""
+        self._no_connects.remove(no_connect_element)
+        del self._uuid_index[no_connect_element.uuid]
+
+        # Remove from position index
+        pos_key = (no_connect_element.position.x, no_connect_element.position.y)
+        if pos_key in self._position_index:
+            self._position_index[pos_key].remove(no_connect_element)
+            if not self._position_index[pos_key]:
+                del self._position_index[pos_key]
+
+    def _mark_modified(self):
+        """Mark collection as modified."""
+        self._modified = True
+
+    # Collection interface methods
+    def __len__(self) -> int:
+        """Return number of no-connects."""
+        return len(self._no_connects)
+
+    def __iter__(self) -> Iterator[NoConnectElement]:
+        """Iterate over no-connects."""
+        return iter(self._no_connects)
+
+    def __getitem__(self, index: int) -> NoConnectElement:
+        """Get no-connect by index."""
+        return self._no_connects[index]
+
+    def __bool__(self) -> bool:
+        """Return True if collection has no-connects."""
+        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