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

kicad_sch_api/core/no_connects.py

@@ -0,0 +1,274 @@
+"""
+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 Point, NoConnect
+
+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

@@ -197,6 +197,7 @@ class SExpressionParser:
             "circles": [],
             "beziers": [],
             "rectangles": [],
+            "images": [],
             "nets": [],
             "lib_symbols": {},
             "sheet_instances": [],
@@ -282,6 +283,10 @@ class SExpressionParser:
                 rectangle = self._parse_rectangle(item)
                 if rectangle:
                     schematic_data["rectangles"].append(rectangle)
+            elif element_type == "image":
+                image = self._parse_image(item)
+                if image:
+                    schematic_data["images"].append(image)
             elif element_type == "lib_symbols":
                 schematic_data["lib_symbols"] = self._parse_lib_symbols(item)
             elif element_type == "sheet_instances":
@@ -357,6 +362,10 @@ class SExpressionParser:
         for graphic in schematic_data.get("graphics", []):
             sexp_data.append(self._graphic_to_sexp(graphic))
 
+        # Images
+        for image in schematic_data.get("images", []):
+            sexp_data.append(self._image_to_sexp(image))
+
         # Circles
         for circle in schematic_data.get("circles", []):
             sexp_data.append(self._circle_to_sexp(circle))
@@ -1108,6 +1117,37 @@ class SExpressionParser:
 
         return rectangle if rectangle else None
 
+    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
+        }
+
+        for elem in item[1:]:
+            if not isinstance(elem, list):
+                continue
+
+            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
+
+            if elem_type == "at" and len(elem) >= 3:
+                image["position"] = {"x": float(elem[1]), "y": float(elem[2])}
+            elif elem_type == "scale" and len(elem) >= 2:
+                image["scale"] = float(elem[1])
+            elif elem_type == "data" and len(elem) >= 2:
+                # The data can be spread across multiple string elements
+                data_parts = []
+                for data_elem in elem[1:]:
+                    data_parts.append(str(data_elem).strip('"'))
+                image["data"] = "".join(data_parts)
+            elif elem_type == "uuid" and len(elem) >= 2:
+                image["uuid"] = str(elem[1]).strip('"')
+
+        return image if image.get("uuid") and image.get("data") else None
+
     def _parse_lib_symbols(self, item: List[Any]) -> Dict[str, Any]:
         """Parse lib_symbols section."""
         # Implementation for lib_symbols parsing
@@ -1933,6 +1973,38 @@ class SExpressionParser:
 
         return sexp
 
+    def _image_to_sexp(self, image_data: Dict[str, Any]) -> List[Any]:
+        """Convert image element to S-expression."""
+        sexp = [sexpdata.Symbol("image")]
+
+        # Add position
+        position = image_data.get("position", {"x": 0, "y": 0})
+        pos_x, pos_y = position["x"], position["y"]
+        sexp.append([sexpdata.Symbol("at"), pos_x, pos_y])
+
+        # Add UUID
+        if "uuid" in image_data:
+            sexp.append([sexpdata.Symbol("uuid"), image_data["uuid"]])
+
+        # Add scale if not default
+        scale = image_data.get("scale", 1.0)
+        if scale != 1.0:
+            sexp.append([sexpdata.Symbol("scale"), scale])
+
+        # Add image data
+        # KiCad splits base64 data into multiple lines for readability
+        # Each line is roughly 76 characters (standard base64 line length)
+        data = image_data.get("data", "")
+        if data:
+            data_sexp = [sexpdata.Symbol("data")]
+            # 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])
+            sexp.append(data_sexp)
+
+        return sexp
+
     def _lib_symbols_to_sexp(self, lib_symbols: Dict[str, Any]) -> List[Any]:
         """Convert lib_symbols to S-expression."""
         sexp = [sexpdata.Symbol("lib_symbols")]

kicad_sch_api/core/schematic.py

@@ -18,13 +18,18 @@ from ..utils.validation import SchematicValidator, ValidationError, ValidationIs
 from .components import ComponentCollection
 from .formatter import ExactFormatter
 from .junctions import JunctionCollection
+from .labels import LabelCollection
+from .nets import NetCollection
+from .no_connects import NoConnectCollection
 from .parser import SExpressionParser
+from .texts import TextCollection
 from .types import (
     HierarchicalLabelShape,
     Junction,
     Label,
     LabelType,
     Net,
+    NoConnect,
     Point,
     SchematicSymbol,
     Sheet,
@@ -136,6 +141,97 @@ class Schematic:
                 junctions.append(junction)
         self._junctions = JunctionCollection(junctions)
 
+        # Initialize text collection
+        text_data = self._data.get("texts", [])
+        texts = []
+        for text_dict in text_data:
+            if isinstance(text_dict, dict):
+                # Convert dict to Text object
+                position = text_dict.get("position", {"x": 0, "y": 0})
+                if isinstance(position, dict):
+                    pos = Point(position["x"], position["y"])
+                elif isinstance(position, (list, tuple)):
+                    pos = Point(position[0], position[1])
+                else:
+                    pos = position
+
+                text = Text(
+                    uuid=text_dict.get("uuid", str(uuid.uuid4())),
+                    position=pos,
+                    text=text_dict.get("text", ""),
+                    rotation=text_dict.get("rotation", 0.0),
+                    size=text_dict.get("size", 1.27),
+                    exclude_from_sim=text_dict.get("exclude_from_sim", False),
+                )
+                texts.append(text)
+        self._texts = TextCollection(texts)
+
+        # Initialize label collection
+        label_data = self._data.get("labels", [])
+        labels = []
+        for label_dict in label_data:
+            if isinstance(label_dict, dict):
+                # Convert dict to Label object
+                position = label_dict.get("position", {"x": 0, "y": 0})
+                if isinstance(position, dict):
+                    pos = Point(position["x"], position["y"])
+                elif isinstance(position, (list, tuple)):
+                    pos = Point(position[0], position[1])
+                else:
+                    pos = position
+
+                label = Label(
+                    uuid=label_dict.get("uuid", str(uuid.uuid4())),
+                    position=pos,
+                    text=label_dict.get("text", ""),
+                    label_type=LabelType(label_dict.get("label_type", "local")),
+                    rotation=label_dict.get("rotation", 0.0),
+                    size=label_dict.get("size", 1.27),
+                    shape=HierarchicalLabelShape(label_dict.get("shape")) if label_dict.get("shape") else None,
+                )
+                labels.append(label)
+        self._labels = LabelCollection(labels)
+
+        # Initialize hierarchical labels collection (filter from labels)
+        hierarchical_labels = [label for label in labels if label.label_type == LabelType.HIERARCHICAL]
+        self._hierarchical_labels = LabelCollection(hierarchical_labels)
+
+        # Initialize no-connect collection
+        no_connect_data = self._data.get("no_connects", [])
+        no_connects = []
+        for no_connect_dict in no_connect_data:
+            if isinstance(no_connect_dict, dict):
+                # Convert dict to NoConnect object
+                position = no_connect_dict.get("position", {"x": 0, "y": 0})
+                if isinstance(position, dict):
+                    pos = Point(position["x"], position["y"])
+                elif isinstance(position, (list, tuple)):
+                    pos = Point(position[0], position[1])
+                else:
+                    pos = position
+
+                no_connect = NoConnect(
+                    uuid=no_connect_dict.get("uuid", str(uuid.uuid4())),
+                    position=pos,
+                )
+                no_connects.append(no_connect)
+        self._no_connects = NoConnectCollection(no_connects)
+
+        # Initialize net collection
+        net_data = self._data.get("nets", [])
+        nets = []
+        for net_dict in net_data:
+            if isinstance(net_dict, dict):
+                # Convert dict to Net object
+                net = Net(
+                    name=net_dict.get("name", ""),
+                    components=net_dict.get("components", []),
+                    wires=net_dict.get("wires", []),
+                    labels=net_dict.get("labels", []),
+                )
+                nets.append(net)
+        self._nets = NetCollection(nets)
+
         # Track modifications for save optimization
         self._modified = False
         self._last_save_time = None
@@ -145,7 +241,10 @@ class Schematic:
         self._total_operation_time = 0.0
 
         logger.debug(
-            f"Schematic initialized with {len(self._components)} components, {len(self._wires)} wires, and {len(self._junctions)} junctions"
+            f"Schematic initialized with {len(self._components)} components, {len(self._wires)} wires, "
+            f"{len(self._junctions)} junctions, {len(self._texts)} texts, {len(self._labels)} labels, "
+            f"{len(self._hierarchical_labels)} hierarchical labels, {len(self._no_connects)} no-connects, "
+            f"and {len(self._nets)} nets"
         )
 
     @classmethod
@@ -276,7 +375,42 @@ class Schematic:
     @property
     def modified(self) -> bool:
         """Whether schematic has been modified since last save."""
-        return self._modified or self._components._modified
+        return (
+            self._modified
+            or self._components._modified
+            or self._wires._modified
+            or self._junctions._modified
+            or self._texts._modified
+            or self._labels._modified
+            or self._hierarchical_labels._modified
+            or self._no_connects._modified
+            or self._nets._modified
+        )
+
+    @property
+    def texts(self) -> TextCollection:
+        """Collection of all text elements in the schematic."""
+        return self._texts
+
+    @property
+    def labels(self) -> LabelCollection:
+        """Collection of all label elements in the schematic."""
+        return self._labels
+
+    @property
+    def hierarchical_labels(self) -> LabelCollection:
+        """Collection of all hierarchical label elements in the schematic."""
+        return self._hierarchical_labels
+
+    @property
+    def no_connects(self) -> NoConnectCollection:
+        """Collection of all no-connect elements in the schematic."""
+        return self._no_connects
+
+    @property
+    def nets(self) -> NetCollection:
+        """Collection of all electrical nets in the schematic."""
+        return self._nets
 
     # Pin positioning methods (migrated from circuit-synth)
     def get_component_pin_position(self, reference: str, pin_number: str) -> Optional[Point]:
@@ -1138,6 +1272,55 @@ class Schematic:
         logger.debug(f"Added text box: '{text}' at {position} size {size}")
         return text_box.uuid
 
+    def add_image(
+        self,
+        position: Union[Point, Tuple[float, float]],
+        data: str,
+        scale: float = 1.0,
+        uuid: Optional[str] = None,
+    ) -> str:
+        """
+        Add an image element.
+
+        Args:
+            position: Image position
+            data: Base64-encoded image data
+            scale: Image scale factor (default 1.0)
+            uuid: Optional UUID (auto-generated if None)
+
+        Returns:
+            UUID of created image element
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        from .types import Image
+
+        import uuid as uuid_module
+
+        image = Image(
+            uuid=uuid if uuid else str(uuid_module.uuid4()),
+            position=position,
+            data=data,
+            scale=scale,
+        )
+
+        if "images" not in self._data:
+            self._data["images"] = []
+
+        self._data["images"].append(
+            {
+                "uuid": image.uuid,
+                "position": {"x": image.position.x, "y": image.position.y},
+                "data": image.data,
+                "scale": image.scale,
+            }
+        )
+        self._modified = True
+
+        logger.debug(f"Added image at {position} with {len(data)} bytes of data")
+        return image.uuid
+
     def add_rectangle(
         self,
         start: Union[Point, Tuple[float, float]],
@@ -1592,9 +1775,7 @@ class Schematic:
                     break
 
         # Fix string/symbol conversion issues in pin definitions
-        print(f"🔧 DEBUG: Before fix - checking for pin definitions...")
         self._fix_symbol_strings_recursively(modified_data)
-        print(f"🔧 DEBUG: After fix - symbol strings fixed")
 
         return modified_data
 
@@ -1607,15 +1788,10 @@ class Schematic:
                 if isinstance(item, list):
                     # Check for pin definitions that need fixing
                     if len(item) >= 3 and item[0] == sexpdata.Symbol("pin"):
-                        print(
-                            f"🔧 DEBUG: Found pin definition: {item[:3]} - types: {[type(x) for x in item[:3]]}"
-                        )
                         # Fix pin type and shape - ensure they are symbols not strings
                         if isinstance(item[1], str):
-                            print(f"🔧 DEBUG: Converting pin type '{item[1]}' to symbol")
                             item[1] = sexpdata.Symbol(item[1])  # pin type: "passive" -> passive
                         if len(item) >= 3 and isinstance(item[2], str):
-                            print(f"🔧 DEBUG: Converting pin shape '{item[2]}' to symbol")
                             item[2] = sexpdata.Symbol(item[2])  # pin shape: "line" -> line
 
                     # Recursively process nested lists