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

kicad_sch_api/core/texts.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 Point, Text
 
 logger = logging.getLogger(__name__)
@@ -124,10 +125,13 @@ class TextElement:
         return f"<Text '{self.text}' @ {self.position}>"
 
 
-class TextCollection:
+class TextCollection(BaseCollection[TextElement]):
     """
     Collection class for efficient text element management.
 
+    Inherits from BaseCollection for standard operations and adds text-specific
+    functionality including content-based indexing.
+
     Provides fast lookup, filtering, and bulk operations for schematic text elements.
     """
 
@@ -138,18 +142,17 @@ class TextCollection:
         Args:
             texts: Initial list of text data
         """
-        self._texts: List[TextElement] = []
-        self._uuid_index: Dict[str, TextElement] = {}
+        # Initialize base collection with empty list (we'll add elements below)
+        super().__init__([], collection_name="texts")
+
+        # Additional text-specific index
         self._content_index: Dict[str, List[TextElement]] = {}
-        self._modified = False
 
         # Add initial texts
         if texts:
             for text_data in texts:
                 self._add_to_indexes(TextElement(text_data, self))
 
-        logger.debug(f"TextCollection initialized with {len(self._texts)} texts")
-
     def add(
         self,
         text: str,
@@ -209,15 +212,10 @@ class TextCollection:
         # Create wrapper and add to collection
         text_element = TextElement(text_data, self)
         self._add_to_indexes(text_element)
-        self._mark_modified()
 
         logger.debug(f"Added text: {text_element}")
         return text_element
 
-    def get(self, text_uuid: str) -> Optional[TextElement]:
-        """Get text by UUID."""
-        return self._uuid_index.get(text_uuid)
-
     def remove(self, text_uuid: str) -> bool:
         """
         Remove text by UUID.
@@ -228,13 +226,19 @@ class TextCollection:
         Returns:
             True if text was removed, False if not found
         """
-        text_element = self._uuid_index.get(text_uuid)
+        text_element = self.get(text_uuid)
         if not text_element:
             return False
 
-        # Remove from indexes
-        self._remove_from_indexes(text_element)
-        self._mark_modified()
+        # Remove from content index
+        content = text_element.text
+        if content in self._content_index:
+            self._content_index[content].remove(text_element)
+            if not self._content_index[content]:
+                del self._content_index[content]
+
+        # Remove using base class method
+        super().remove(text_uuid)
 
         logger.debug(f"Removed text: {text_element}")
         return True
@@ -254,14 +258,14 @@ class TextCollection:
             return self._content_index.get(content, []).copy()
         else:
             matches = []
-            for text_element in self._texts:
+            for text_element in self._items:
                 if content.lower() in text_element.text.lower():
                     matches.append(text_element)
             return matches
 
     def filter(self, predicate: Callable[[TextElement], bool]) -> List[TextElement]:
         """
-        Filter texts by predicate function.
+        Filter texts by predicate function (delegates to base class find).
 
         Args:
             predicate: Function that returns True for texts to include
@@ -269,7 +273,7 @@ class TextCollection:
         Returns:
             List of texts matching predicate
         """
-        return [text for text in self._texts if predicate(text)]
+        return self.find(predicate)
 
     def bulk_update(self, criteria: Callable[[TextElement], bool], updates: Dict[str, Any]):
         """
@@ -280,7 +284,7 @@ class TextCollection:
             updates: Dictionary of property updates
         """
         updated_count = 0
-        for text_element in self._texts:
+        for text_element in self._items:
             if criteria(text_element):
                 for prop, value in updates.items():
                     if hasattr(text_element, prop):
@@ -293,15 +297,12 @@ class TextCollection:
 
     def clear(self):
         """Remove all texts from collection."""
-        self._texts.clear()
-        self._uuid_index.clear()
         self._content_index.clear()
-        self._mark_modified()
+        super().clear()
 
     def _add_to_indexes(self, text_element: TextElement):
-        """Add text to internal indexes."""
-        self._texts.append(text_element)
-        self._uuid_index[text_element.uuid] = text_element
+        """Add text to internal indexes (base + content index)."""
+        self._add_item(text_element)
 
         # Add to content index
         content = text_element.text
@@ -309,35 +310,7 @@ class TextCollection:
             self._content_index[content] = []
         self._content_index[content].append(text_element)
 
-    def _remove_from_indexes(self, text_element: TextElement):
-        """Remove text from internal indexes."""
-        self._texts.remove(text_element)
-        del self._uuid_index[text_element.uuid]
-
-        # Remove from content index
-        content = text_element.text
-        if content in self._content_index:
-            self._content_index[content].remove(text_element)
-            if not self._content_index[content]:
-                del self._content_index[content]
-
-    def _mark_modified(self):
-        """Mark collection as modified."""
-        self._modified = True
-
-    # Collection interface methods
-    def __len__(self) -> int:
-        """Return number of texts."""
-        return len(self._texts)
-
-    def __iter__(self) -> Iterator[TextElement]:
-        """Iterate over texts."""
-        return iter(self._texts)
-
-    def __getitem__(self, index: int) -> TextElement:
-        """Get text by index."""
-        return self._texts[index]
-
+    # Collection interface methods - __len__, __iter__, __getitem__ inherited from BaseCollection
     def __bool__(self) -> bool:
         """Return True if collection has texts."""
-        return len(self._texts) > 0
+        return len(self._items) > 0

kicad_sch_api/core/types.py

@@ -18,14 +18,14 @@ class Point:
     x: float
     y: float
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         # Ensure coordinates are float
         object.__setattr__(self, "x", float(self.x))
         object.__setattr__(self, "y", float(self.y))
 
     def distance_to(self, other: "Point") -> float:
         """Calculate distance to another point."""
-        return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5
+        return float(((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5)
 
     def offset(self, dx: float, dy: float) -> "Point":
         """Create new point offset by dx, dy."""
@@ -35,6 +35,43 @@ class Point:
         return f"({self.x:.3f}, {self.y:.3f})"
 
 
+def point_from_dict_or_tuple(
+    position: Union[Point, Dict[str, float], Tuple[float, float], List[float], Any]
+) -> Point:
+    """
+    Convert various position formats to a Point object.
+
+    Supports multiple input formats for maximum flexibility:
+    - Point: Returns as-is
+    - Dict with 'x' and 'y' keys: Extracts and creates Point
+    - Tuple/List with 2 elements: Creates Point from coordinates
+    - Other: Returns as-is (assumes it's already a Point-like object)
+
+    Args:
+        position: Position in any supported format
+
+    Returns:
+        Point object
+
+    Example:
+        >>> point_from_dict_or_tuple({"x": 10, "y": 20})
+        Point(x=10.0, y=20.0)
+        >>> point_from_dict_or_tuple((10, 20))
+        Point(x=10.0, y=20.0)
+        >>> point_from_dict_or_tuple(Point(10, 20))
+        Point(x=10.0, y=20.0)
+    """
+    if isinstance(position, Point):
+        return position
+    elif isinstance(position, dict):
+        return Point(position.get("x", 0), position.get("y", 0))
+    elif isinstance(position, (list, tuple)) and len(position) >= 2:
+        return Point(position[0], position[1])
+    else:
+        # Assume it's already a Point-like object or will be handled by caller
+        return position
+
+
 @dataclass(frozen=True)
 class Rectangle:
     """Rectangle defined by two corner points."""
@@ -110,7 +147,7 @@ class SchematicPin:
     length: float = 2.54  # Standard pin length in mm
     rotation: float = 0.0  # Rotation in degrees
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         # Ensure types are correct
         self.pin_type = PinType(self.pin_type) if isinstance(self.pin_type, str) else self.pin_type
         self.pin_shape = (
@@ -135,7 +172,7 @@ class SchematicSymbol:
     on_board: bool = True
     unit: int = 1
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         # Generate UUID if not provided
         if not self.uuid:
             self.uuid = str(uuid4())
@@ -163,6 +200,10 @@ class SchematicSymbol:
         if not pin:
             return None
         # TODO: Apply rotation and symbol position transformation
+        # NOTE: Currently assumes 0° rotation. For rotated components, pin positions
+        # would need to be transformed using rotation matrix before adding to component position.
+        # This affects pin-to-pin wiring accuracy for rotated components.
+        # Priority: MEDIUM - Would improve wiring accuracy for rotated components
         return Point(self.position.x + pin.position.x, self.position.y + pin.position.y)
 
 
@@ -183,7 +224,7 @@ class Wire:
     stroke_width: float = 0.0
     stroke_type: str = "default"
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -196,7 +237,7 @@ class Wire:
             raise ValueError("Wire must have at least 2 points")
 
     @classmethod
-    def from_start_end(cls, uuid: str, start: Point, end: Point, **kwargs) -> "Wire":
+    def from_start_end(cls, uuid: str, start: Point, end: Point, **kwargs: Any) -> "Wire":
         """Create wire from start and end points (convenience method)."""
         return cls(uuid=uuid, points=[start, end], **kwargs)
 
@@ -244,7 +285,7 @@ class Junction:
     diameter: float = 0  # KiCAD default diameter
     color: Tuple[int, int, int, int] = (0, 0, 0, 0)  # RGBA color
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -280,7 +321,7 @@ class Label:
     size: float = 1.27
     shape: Optional[HierarchicalLabelShape] = None  # Only for hierarchical labels
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -305,7 +346,7 @@ class Text:
     size: float = 1.27
     exclude_from_sim: bool = False
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -333,7 +374,7 @@ class TextBox:
     justify_vertical: str = "top"
     exclude_from_sim: bool = False
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -349,7 +390,7 @@ class SchematicRectangle:
     stroke_type: str = "default"
     fill_type: str = "none"
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -366,10 +407,7 @@ class SchematicRectangle:
     @property
     def center(self) -> Point:
         """Rectangle center point."""
-        return Point(
-            (self.start.x + self.end.x) / 2,
-            (self.start.y + self.end.y) / 2
-        )
+        return Point((self.start.x + self.end.x) / 2, (self.start.y + self.end.y) / 2)
 
 
 @dataclass
@@ -381,7 +419,7 @@ class Image:
     data: str  # Base64-encoded image data
     scale: float = 1.0
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -393,7 +431,7 @@ class NoConnect:
     uuid: str
     position: Point
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -407,13 +445,13 @@ class Net:
     wires: List[str] = field(default_factory=list)  # Wire UUIDs
     labels: List[str] = field(default_factory=list)  # Label UUIDs
 
-    def add_connection(self, reference: str, pin: str):
+    def add_connection(self, reference: str, pin: str) -> None:
         """Add component pin to net."""
         connection = (reference, pin)
         if connection not in self.components:
             self.components.append(connection)
 
-    def remove_connection(self, reference: str, pin: str):
+    def remove_connection(self, reference: str, pin: str) -> None:
         """Remove component pin from net."""
         connection = (reference, pin)
         if connection in self.components:
@@ -439,7 +477,7 @@ class Sheet:
     stroke_type: str = "solid"
     fill_color: Tuple[float, float, float, float] = (0, 0, 0, 0.0)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -454,7 +492,7 @@ class SheetPin:
     pin_type: PinType = PinType.BIDIRECTIONAL
     size: float = 1.27
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 
@@ -497,7 +535,7 @@ class Schematic:
     rectangles: List[SchematicRectangle] = field(default_factory=list)
     lib_symbols: Dict[str, Any] = field(default_factory=dict)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.uuid:
             self.uuid = str(uuid4())
 

kicad_sch_api/core/wires.py

@@ -9,56 +9,36 @@ import logging
 import uuid as uuid_module
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+from .collections import BaseCollection
 from .types import Point, Wire, WireType
 
 logger = logging.getLogger(__name__)
 
 
-class WireCollection:
+class WireCollection(BaseCollection[Wire]):
     """
     Professional wire collection with enhanced management features.
 
+    Inherits from BaseCollection for standard operations and adds wire-specific
+    functionality.
+
     Features:
-    - Fast UUID-based lookup and indexing
-    - Bulk operations for performance
+    - Fast UUID-based lookup and indexing (inherited)
+    - Bulk operations for performance (inherited)
     - Multi-point wire support
     - Validation and conflict detection
     - Junction management integration
+    - Wire geometry queries (horizontal, vertical, by-point)
     """
 
-    def __init__(self, wires: Optional[List[Wire]] = None):
+    def __init__(self, wires: Optional[List[Wire]] = None) -> None:
         """
         Initialize wire collection.
 
         Args:
             wires: Initial list of wires
         """
-        self._wires: List[Wire] = wires or []
-        self._uuid_index: Dict[str, int] = {}
-        self._modified = False
-
-        # Build UUID index
-        self._rebuild_index()
-
-        logger.debug(f"WireCollection initialized with {len(self._wires)} wires")
-
-    def _rebuild_index(self):
-        """Rebuild UUID index for fast lookups."""
-        self._uuid_index = {wire.uuid: i for i, wire in enumerate(self._wires)}
-
-    def __len__(self) -> int:
-        """Number of wires in collection."""
-        return len(self._wires)
-
-    def __iter__(self):
-        """Iterate over wires."""
-        return iter(self._wires)
-
-    def __getitem__(self, uuid: str) -> Wire:
-        """Get wire by UUID."""
-        if uuid not in self._uuid_index:
-            raise KeyError(f"Wire with UUID '{uuid}' not found")
-        return self._wires[self._uuid_index[uuid]]
+        super().__init__(wires, collection_name="wires")
 
     def add(
         self,
@@ -114,37 +94,14 @@ class WireCollection:
         # Create wire
         wire = Wire(uuid=uuid, points=wire_points, wire_type=wire_type, stroke_width=stroke_width)
 
-        # Add to collection
-        self._wires.append(wire)
-        self._uuid_index[uuid] = len(self._wires) - 1
-        self._modified = True
+        # Add to collection using base class method
+        self._add_item(wire)
 
         logger.debug(f"Added wire: {len(wire_points)} points, UUID={uuid}")
         return uuid
 
-    def remove(self, uuid: str) -> bool:
-        """
-        Remove wire by UUID.
-
-        Args:
-            uuid: Wire UUID to remove
-
-        Returns:
-            True if wire was removed, False if not found
-        """
-        if uuid not in self._uuid_index:
-            return False
-
-        index = self._uuid_index[uuid]
-        del self._wires[index]
-        self._rebuild_index()
-        self._modified = True
-
-        logger.debug(f"Removed wire: {uuid}")
-        return True
-
     def get_by_point(
-        self, point: Union[Point, Tuple[float, float]], tolerance: float = None
+        self, point: Union[Point, Tuple[float, float]], tolerance: Optional[float] = None
     ) -> List[Wire]:
         """
         Find wires that pass through or near a point.
@@ -164,7 +121,7 @@ class WireCollection:
             point = Point(point[0], point[1])
 
         matching_wires = []
-        for wire in self._wires:
+        for wire in self._items:
             # Check if any wire point is close
             for wire_point in wire.points:
                 if wire_point.distance_to(point) <= tolerance:
@@ -213,40 +170,35 @@ class WireCollection:
 
     def get_horizontal_wires(self) -> List[Wire]:
         """Get all horizontal wires."""
-        return [wire for wire in self._wires if wire.is_horizontal()]
+        return [wire for wire in self._items if wire.is_horizontal()]
 
     def get_vertical_wires(self) -> List[Wire]:
         """Get all vertical wires."""
-        return [wire for wire in self._wires if wire.is_vertical()]
+        return [wire for wire in self._items if wire.is_vertical()]
 
     def get_statistics(self) -> Dict[str, Any]:
-        """Get wire collection statistics."""
-        total_length = sum(wire.length for wire in self._wires)
-        simple_wires = sum(1 for wire in self._wires if wire.is_simple())
-        multi_point_wires = len(self._wires) - simple_wires
+        """Get wire collection statistics (extends base statistics)."""
+        base_stats = super().get_statistics()
+        total_length = sum(wire.length for wire in self._items)
+        simple_wires = sum(1 for wire in self._items if wire.is_simple())
+        multi_point_wires = len(self._items) - simple_wires
 
         return {
-            "total_wires": len(self._wires),
+            **base_stats,
+            "total_wires": len(self._items),
             "simple_wires": simple_wires,
             "multi_point_wires": multi_point_wires,
             "total_length": total_length,
-            "avg_length": total_length / len(self._wires) if self._wires else 0,
+            "avg_length": total_length / len(self._items) if self._items else 0,
             "horizontal_wires": len(self.get_horizontal_wires()),
             "vertical_wires": len(self.get_vertical_wires()),
         }
 
-    def clear(self):
-        """Remove all wires from collection."""
-        self._wires.clear()
-        self._uuid_index.clear()
-        self._modified = True
-        logger.debug("Cleared all wires")
-
     @property
     def modified(self) -> bool:
         """Check if collection has been modified."""
-        return self._modified
+        return self.is_modified()
 
-    def mark_saved(self):
+    def mark_saved(self) -> None:
         """Mark collection as saved (reset modified flag)."""
-        self._modified = False
+        self.reset_modified_flag()

kicad_sch_api/geometry/font_metrics.py

@@ -17,4 +17,6 @@ DEFAULT_PIN_NUMBER_SIZE = 1.27  # 50 mils
 # Text width ratio for proportional font rendering
 # KiCad uses proportional fonts where average character width is ~0.65x height
 # This prevents label text from extending beyond calculated bounding boxes
-DEFAULT_PIN_TEXT_WIDTH_RATIO = 0.65  # Width to height ratio for pin text (proportional font average)
+DEFAULT_PIN_TEXT_WIDTH_RATIO = (
+    0.65  # Width to height ratio for pin text (proportional font average)
+)