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

kicad_sch_api/core/labels.py

@@ -10,6 +10,7 @@ import uuid
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
 
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
+from .collections import BaseCollection
 from .types import Label, Point
 
 logger = logging.getLogger(__name__)
@@ -114,10 +115,13 @@ class LabelElement:
         return f"<Label '{self.text}' @ {self.position}>"
 
 
-class LabelCollection:
+class LabelCollection(BaseCollection[LabelElement]):
     """
     Collection class for efficient label element management.
 
+    Inherits from BaseCollection for standard operations and adds label-specific
+    functionality including text-based indexing.
+
     Provides fast lookup, filtering, and bulk operations for schematic label elements.
     """
 
@@ -128,18 +132,17 @@ class LabelCollection:
         Args:
             labels: Initial list of label data
         """
-        self._labels: List[LabelElement] = []
-        self._uuid_index: Dict[str, LabelElement] = {}
+        # Initialize base collection
+        super().__init__([], collection_name="labels")
+
+        # Additional label-specific index
         self._text_index: Dict[str, List[LabelElement]] = {}
-        self._modified = False
 
         # Add initial labels
         if labels:
             for label_data in labels:
                 self._add_to_indexes(LabelElement(label_data, self))
 
-        logger.debug(f"LabelCollection initialized with {len(self._labels)} labels")
-
     def add(
         self,
         text: str,
@@ -201,9 +204,7 @@ class LabelCollection:
         logger.debug(f"Added label: {label_element}")
         return label_element
 
-    def get(self, label_uuid: str) -> Optional[LabelElement]:
-        """Get label by UUID."""
-        return self._uuid_index.get(label_uuid)
+    # get() method inherited from BaseCollection
 
     def get_by_text(self, text: str) -> List[LabelElement]:
         """Get all labels with the given text."""
@@ -219,13 +220,19 @@ class LabelCollection:
         Returns:
             True if label was removed, False if not found
         """
-        label_element = self._uuid_index.get(label_uuid)
+        label_element = self.get(label_uuid)
         if not label_element:
             return False
 
-        # Remove from indexes
-        self._remove_from_indexes(label_element)
-        self._mark_modified()
+        # Remove from text index
+        text = label_element.text
+        if text in self._text_index:
+            self._text_index[text].remove(label_element)
+            if not self._text_index[text]:
+                del self._text_index[text]
+
+        # Remove using base class method
+        super().remove(label_uuid)
 
         logger.debug(f"Removed label: {label_element}")
         return True
@@ -245,7 +252,7 @@ class LabelCollection:
             return self._text_index.get(text, []).copy()
         else:
             matches = []
-            for label_element in self._labels:
+            for label_element in self._items:
                 if text.lower() in label_element.text.lower():
                     matches.append(label_element)
             return matches
@@ -260,7 +267,7 @@ class LabelCollection:
         Returns:
             List of labels matching predicate
         """
-        return [label for label in self._labels if predicate(label)]
+        return [label for label in self._items if predicate(label)]
 
     def bulk_update(self, criteria: Callable[[LabelElement], bool], updates: Dict[str, Any]):
         """
@@ -271,7 +278,7 @@ class LabelCollection:
             updates: Dictionary of property updates
         """
         updated_count = 0
-        for label_element in self._labels:
+        for label_element in self._items:
             if criteria(label_element):
                 for prop, value in updates.items():
                     if hasattr(label_element, prop):
@@ -284,15 +291,12 @@ class LabelCollection:
 
     def clear(self):
         """Remove all labels from collection."""
-        self._labels.clear()
-        self._uuid_index.clear()
         self._text_index.clear()
-        self._mark_modified()
+        super().clear()
 
     def _add_to_indexes(self, label_element: LabelElement):
-        """Add label to internal indexes."""
-        self._labels.append(label_element)
-        self._uuid_index[label_element.uuid] = label_element
+        """Add label to internal indexes (base + text index)."""
+        self._add_item(label_element)
 
         # Add to text index
         text = label_element.text
@@ -300,18 +304,6 @@ class LabelCollection:
             self._text_index[text] = []
         self._text_index[text].append(label_element)
 
-    def _remove_from_indexes(self, label_element: LabelElement):
-        """Remove label from internal indexes."""
-        self._labels.remove(label_element)
-        del self._uuid_index[label_element.uuid]
-
-        # Remove from text index
-        text = label_element.text
-        if text in self._text_index:
-            self._text_index[text].remove(label_element)
-            if not self._text_index[text]:
-                del self._text_index[text]
-
     def _update_text_index(self, old_text: str, label_element: LabelElement):
         """Update text index when label text changes."""
         # Remove from old text index
@@ -326,23 +318,7 @@ class LabelCollection:
             self._text_index[new_text] = []
         self._text_index[new_text].append(label_element)
 
-    def _mark_modified(self):
-        """Mark collection as modified."""
-        self._modified = True
-
-    # Collection interface methods
-    def __len__(self) -> int:
-        """Return number of labels."""
-        return len(self._labels)
-
-    def __iter__(self) -> Iterator[LabelElement]:
-        """Iterate over labels."""
-        return iter(self._labels)
-
-    def __getitem__(self, index: int) -> LabelElement:
-        """Get label by index."""
-        return self._labels[index]
-
+    # Collection interface methods - __len__, __iter__, __getitem__ inherited from BaseCollection
     def __bool__(self) -> bool:
         """Return True if collection has labels."""
-        return len(self._labels) > 0
+        return len(self._items) > 0

kicad_sch_api/core/managers/file_io.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
 from ...utils.validation import ValidationError
+from ..config import config
 from ..formatter import ExactFormatter
 from ..parser import SExpressionParser
 
@@ -219,9 +220,9 @@ class FileIOManager:
         return {
             "kicad_sch": {
                 "version": 20230819,
-                "generator": "kicad-sch-api",
+                "generator": config.file_format.generator_default,
                 "uuid": None,  # Will be set by calling code
-                "paper": "A4",
+                "paper": config.paper.default,
                 "lib_symbols": {},
                 "symbol": [],
                 "wire": [],

kicad_sch_api/core/managers/metadata.py

@@ -39,10 +39,10 @@ class MetadataManager:
         Args:
             paper: Paper size (e.g., "A4", "A3", "Letter", "Legal")
         """
-        valid_sizes = ["A4", "A3", "A2", "A1", "A0", "Letter", "Legal", "Tabloid"]
+        from ..config import config
 
-        if paper not in valid_sizes:
-            logger.warning(f"Unusual paper size: {paper}. Valid sizes: {valid_sizes}")
+        if paper not in config.paper.valid_sizes:
+            logger.warning(f"Unusual paper size: {paper}. Valid sizes: {config.paper.valid_sizes}")
 
         self._data["paper"] = paper
         logger.debug(f"Set paper size: {paper}")
@@ -260,9 +260,10 @@ class MetadataManager:
             issues.append("Title block missing title")
 
         # Check paper size
+        from ..config import config
+
         paper = self.get_paper_size()
-        valid_sizes = ["A4", "A3", "A2", "A1", "A0", "Letter", "Legal", "Tabloid"]
-        if paper and paper not in valid_sizes:
+        if paper and paper not in config.paper.valid_sizes:
             issues.append(f"Non-standard paper size: {paper}")
 
         return issues

kicad_sch_api/core/managers/validation.py

@@ -274,9 +274,10 @@ class ValidationManager:
             )
 
         # Check paper size
+        from ..config import config
+
         paper = self._data.get("paper")
-        valid_papers = ["A4", "A3", "A2", "A1", "A0", "Letter", "Legal", "Tabloid"]
-        if paper and paper not in valid_papers:
+        if paper and paper not in config.paper.valid_sizes:
             issues.append(
                 ValidationIssue(
                     category="metadata",

kicad_sch_api/core/managers/wire.py

@@ -305,7 +305,13 @@ class WireManager:
                 return True
 
         # TODO: Implement more sophisticated connectivity analysis
-        # This would involve following wire networks through junctions
+        # 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(

kicad_sch_api/core/nets.py

@@ -9,6 +9,7 @@ import logging
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
 
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
+from .collections import BaseCollection
 from .types import Net
 
 logger = logging.getLogger(__name__)
@@ -35,6 +36,11 @@ class NetElement:
         self._validator = SchematicValidator()
 
     # Core properties with validation
+    @property
+    def uuid(self) -> str:
+        """Net UUID (uses name as unique identifier)."""
+        return self._data.name
+
     @property
     def name(self) -> str:
         """Net name."""
@@ -47,7 +53,9 @@ class NetElement:
             raise ValidationError("Net name cannot be empty")
         old_name = self._data.name
         self._data.name = value.strip()
+        # Update name index and rebuild base UUID index since UUID changed
         self._collection._update_name_index(old_name, self)
+        self._collection._rebuild_index()
         self._collection._mark_modified()
 
     @property
@@ -117,11 +125,15 @@ class NetElement:
         return f"<Net '{self.name}' ({len(self.components)} connections)>"
 
 
-class NetCollection:
+class NetCollection(BaseCollection[NetElement]):
     """
     Collection class for efficient net management.
 
+    Inherits from BaseCollection for standard operations and adds net-specific
+    functionality including name-based indexing.
+
     Provides fast lookup, filtering, and bulk operations for schematic nets.
+    Note: Nets use name as the unique identifier (exposed as .uuid for protocol compatibility).
     """
 
     def __init__(self, nets: List[Net] = None):
@@ -131,17 +143,17 @@ class NetCollection:
         Args:
             nets: Initial list of net data
         """
-        self._nets: List[NetElement] = []
+        # Initialize base collection
+        super().__init__([], collection_name="nets")
+
+        # Additional net-specific index (for convenience, duplicates base UUID index)
         self._name_index: Dict[str, NetElement] = {}
-        self._modified = False
 
         # Add initial nets
         if nets:
             for net_data in nets:
                 self._add_to_indexes(NetElement(net_data, self))
 
-        logger.debug(f"NetCollection initialized with {len(self._nets)} nets")
-
     def add(
         self,
         name: str,
@@ -190,9 +202,11 @@ class NetCollection:
         logger.debug(f"Added net: {net_element}")
         return net_element
 
-    def get(self, name: str) -> Optional[NetElement]:
-        """Get net by name."""
-        return self._name_index.get(name)
+    def get_by_name(self, name: str) -> Optional[NetElement]:
+        """Get net by name (convenience method, equivalent to get(name))."""
+        return self.get(name)
+
+    # get() method inherited from BaseCollection (uses name as UUID)
 
     def remove(self, name: str) -> bool:
         """
@@ -204,13 +218,16 @@ class NetCollection:
         Returns:
             True if net was removed, False if not found
         """
-        net_element = self._name_index.get(name)
+        net_element = self.get(name)
         if not net_element:
             return False
 
-        # Remove from indexes
-        self._remove_from_indexes(net_element)
-        self._mark_modified()
+        # Remove from name index
+        if net_element.name in self._name_index:
+            del self._name_index[net_element.name]
+
+        # Remove using base class method
+        super().remove(name)
 
         logger.debug(f"Removed net: {net_element}")
         return True
@@ -227,7 +244,7 @@ class NetCollection:
             List of matching net elements
         """
         matches = []
-        for net_element in self._nets:
+        for net_element in self._items:
             for comp_ref, comp_pin in net_element.components:
                 if comp_ref == reference and (pin is None or comp_pin == pin):
                     matches.append(net_element)
@@ -236,7 +253,7 @@ class NetCollection:
 
     def filter(self, predicate: Callable[[NetElement], bool]) -> List[NetElement]:
         """
-        Filter nets by predicate function.
+        Filter nets by predicate function (delegates to base class find).
 
         Args:
             predicate: Function that returns True for nets to include
@@ -244,7 +261,7 @@ class NetCollection:
         Returns:
             List of nets matching predicate
         """
-        return [net for net in self._nets if predicate(net)]
+        return self.find(predicate)
 
     def bulk_update(self, criteria: Callable[[NetElement], bool], updates: Dict[str, Any]):
         """
@@ -255,7 +272,7 @@ class NetCollection:
             updates: Dictionary of property updates
         """
         updated_count = 0
-        for net_element in self._nets:
+        for net_element in self._items:
             if criteria(net_element):
                 for prop, value in updates.items():
                     if hasattr(net_element, prop):
@@ -268,43 +285,21 @@ class NetCollection:
 
     def clear(self):
         """Remove all nets from collection."""
-        self._nets.clear()
         self._name_index.clear()
-        self._mark_modified()
+        super().clear()
 
     def _add_to_indexes(self, net_element: NetElement):
-        """Add net to internal indexes."""
-        self._nets.append(net_element)
+        """Add net to internal indexes (base + name index)."""
+        self._add_item(net_element)
         self._name_index[net_element.name] = net_element
 
-    def _remove_from_indexes(self, net_element: NetElement):
-        """Remove net from internal indexes."""
-        self._nets.remove(net_element)
-        del self._name_index[net_element.name]
-
     def _update_name_index(self, old_name: str, net_element: NetElement):
         """Update name index when net name changes."""
         if old_name in self._name_index:
             del self._name_index[old_name]
         self._name_index[net_element.name] = net_element
 
-    def _mark_modified(self):
-        """Mark collection as modified."""
-        self._modified = True
-
-    # Collection interface methods
-    def __len__(self) -> int:
-        """Return number of nets."""
-        return len(self._nets)
-
-    def __iter__(self) -> Iterator[NetElement]:
-        """Iterate over nets."""
-        return iter(self._nets)
-
-    def __getitem__(self, index: int) -> NetElement:
-        """Get net by index."""
-        return self._nets[index]
-
+    # Collection interface methods - __len__, __iter__, __getitem__ inherited from BaseCollection
     def __bool__(self) -> bool:
         """Return True if collection has nets."""
-        return len(self._nets) > 0
+        return len(self._items) > 0

kicad_sch_api/core/no_connects.py

@@ -10,6 +10,7 @@ import uuid
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
 
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
+from .collections import BaseCollection
 from .types import NoConnect, Point
 
 logger = logging.getLogger(__name__)
@@ -72,10 +73,13 @@ class NoConnectElement:
         return f"<NoConnect @ {self.position}>"
 
 
-class NoConnectCollection:
+class NoConnectCollection(BaseCollection[NoConnectElement]):
     """
     Collection class for efficient no-connect element management.
 
+    Inherits from BaseCollection for standard operations and adds no-connect-specific
+    functionality including position-based indexing.
+
     Provides fast lookup, filtering, and bulk operations for schematic no-connect elements.
     """
 
@@ -86,18 +90,17 @@ class NoConnectCollection:
         Args:
             no_connects: Initial list of no-connect data
         """
-        self._no_connects: List[NoConnectElement] = []
-        self._uuid_index: Dict[str, NoConnectElement] = {}
+        # Initialize base collection
+        super().__init__([], collection_name="no_connects")
+
+        # Additional no-connect-specific index
         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]],
@@ -144,9 +147,7 @@ class NoConnectCollection:
         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)
+    # get() method inherited from BaseCollection
 
     def remove(self, no_connect_uuid: str) -> bool:
         """
@@ -158,13 +159,19 @@ class NoConnectCollection:
         Returns:
             True if no-connect was removed, False if not found
         """
-        no_connect_element = self._uuid_index.get(no_connect_uuid)
+        no_connect_element = self.get(no_connect_uuid)
         if not no_connect_element:
             return False
 
-        # Remove from indexes
-        self._remove_from_indexes(no_connect_element)
-        self._mark_modified()
+        # 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]
+
+        # Remove using base class method
+        super().remove(no_connect_uuid)
 
         logger.debug(f"Removed no-connect: {no_connect_element}")
         return True
@@ -186,7 +193,7 @@ class NoConnectCollection:
             position = Point(position[0], position[1])
 
         matches = []
-        for no_connect_element in self._no_connects:
+        for no_connect_element in self._items:
             distance = no_connect_element.position.distance_to(position)
             if distance <= tolerance:
                 matches.append(no_connect_element)
@@ -194,7 +201,7 @@ class NoConnectCollection:
 
     def filter(self, predicate: Callable[[NoConnectElement], bool]) -> List[NoConnectElement]:
         """
-        Filter no-connects by predicate function.
+        Filter no-connects by predicate function (delegates to base class find).
 
         Args:
             predicate: Function that returns True for no-connects to include
@@ -202,7 +209,7 @@ class NoConnectCollection:
         Returns:
             List of no-connects matching predicate
         """
-        return [no_connect for no_connect in self._no_connects if predicate(no_connect)]
+        return self.find(predicate)
 
     def bulk_update(self, criteria: Callable[[NoConnectElement], bool], updates: Dict[str, Any]):
         """
@@ -213,7 +220,7 @@ class NoConnectCollection:
             updates: Dictionary of property updates
         """
         updated_count = 0
-        for no_connect_element in self._no_connects:
+        for no_connect_element in self._items:
             if criteria(no_connect_element):
                 for prop, value in updates.items():
                     if hasattr(no_connect_element, prop):
@@ -226,15 +233,12 @@ class NoConnectCollection:
 
     def clear(self):
         """Remove all no-connects from collection."""
-        self._no_connects.clear()
-        self._uuid_index.clear()
         self._position_index.clear()
-        self._mark_modified()
+        super().clear()
 
     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 no-connect to internal indexes (base + position index)."""
+        self._add_item(no_connect_element)
 
         # Add to position index
         pos_key = (no_connect_element.position.x, no_connect_element.position.y)
@@ -242,35 +246,7 @@ class NoConnectCollection:
             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]
-
+    # Collection interface methods - __len__, __iter__, __getitem__ inherited from BaseCollection
     def __bool__(self) -> bool:
         """Return True if collection has no-connects."""
-        return len(self._no_connects) > 0
+        return len(self._items) > 0