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

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())
 
@@ -378,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())
 
@@ -390,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())
 
@@ -404,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:
@@ -436,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())
 
@@ -451,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())
 
@@ -494,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/parsers/elements/__init__.py

@@ -0,0 +1,22 @@
+"""
+Element-specific parsers for KiCAD schematic elements.
+
+This module contains specialized parsers for different schematic element types,
+extracted from the monolithic parser.py for better maintainability.
+"""
+
+from .graphics_parser import GraphicsParser
+
+# Additional element parsers will be imported here as they are created
+# from .wire_parser import WireParser
+# from .label_parser import LabelParser
+# from .text_parser import TextParser
+# from .sheet_parser import SheetParser
+# from .library_parser import LibraryParser
+# from .symbol_parser import SymbolParser
+# from .metadata_parser import MetadataParser
+
+__all__ = [
+    "GraphicsParser",
+    # Will be populated as parsers are added
+]