kicad-sch-api 0.3.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

kicad_sch_api/collections/wires.py

@@ -0,0 +1,292 @@
+"""
+Enhanced wire management with IndexRegistry integration.
+
+Provides WireCollection using BaseCollection infrastructure with
+endpoint indexing and wire geometry queries.
+"""
+
+import logging
+import uuid as uuid_module
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from ..core.types import Point, Wire, WireType
+from .base import BaseCollection, IndexSpec, ValidationLevel
+
+logger = logging.getLogger(__name__)
+
+
+class WireCollection(BaseCollection[Wire]):
+    """
+    Wire collection with endpoint indexing and geometry queries.
+
+    Inherits from BaseCollection for UUID indexing and adds wire-specific
+    functionality for endpoint queries and wire type filtering.
+
+    Features:
+    - Fast UUID lookup via IndexRegistry
+    - Multi-point wire support
+    - Endpoint-based queries
+    - Horizontal/vertical wire detection
+    - Lazy index rebuilding
+    - Batch mode support
+    """
+
+    def __init__(
+        self,
+        wires: Optional[List[Wire]] = None,
+        validation_level: ValidationLevel = ValidationLevel.NORMAL,
+    ):
+        """
+        Initialize wire collection.
+
+        Args:
+            wires: Initial list of wires
+            validation_level: Validation level for operations
+        """
+        super().__init__(validation_level=validation_level)
+
+        # Add initial wires
+        if wires:
+            with self.batch_mode():
+                for wire in wires:
+                    super().add(wire)
+
+        logger.debug(f"WireCollection initialized with {len(self)} wires")
+
+    # BaseCollection abstract method implementations
+    def _get_item_uuid(self, item: Wire) -> str:
+        """Extract UUID from wire."""
+        return item.uuid
+
+    def _create_item(self, **kwargs) -> Wire:
+        """Create a new wire (not typically used directly)."""
+        raise NotImplementedError("Use add() method to create wires")
+
+    def _get_index_specs(self) -> List[IndexSpec]:
+        """Get index specifications for wire collection."""
+        return [
+            IndexSpec(
+                name="uuid",
+                key_func=lambda w: w.uuid,
+                unique=True,
+                description="UUID index for fast lookups",
+            ),
+        ]
+
+    # Wire-specific add method
+    def add(
+        self,
+        start: Optional[Union[Point, Tuple[float, float]]] = None,
+        end: Optional[Union[Point, Tuple[float, float]]] = None,
+        points: Optional[List[Union[Point, Tuple[float, float]]]] = None,
+        wire_type: WireType = WireType.WIRE,
+        stroke_width: float = 0.0,
+        uuid: Optional[str] = None,
+    ) -> str:
+        """
+        Add a wire to the collection.
+
+        Args:
+            start: Start point (for simple wires)
+            end: End point (for simple wires)
+            points: List of points (for multi-point wires)
+            wire_type: Wire type (wire or bus)
+            stroke_width: Line width
+            uuid: Optional UUID (auto-generated if not provided)
+
+        Returns:
+            UUID of the created wire
+
+        Raises:
+            ValueError: If neither start/end nor points are provided
+            ValueError: If UUID already exists
+        """
+        # Generate UUID if not provided
+        if uuid is None:
+            uuid = str(uuid_module.uuid4())
+        else:
+            # Check for duplicate
+            self._ensure_indexes_current()
+            if self._index_registry.has_key("uuid", uuid):
+                raise ValueError(f"Wire with UUID '{uuid}' already exists")
+
+        # Convert points
+        wire_points = []
+        if points:
+            # Multi-point wire
+            for point in points:
+                if isinstance(point, tuple):
+                    wire_points.append(Point(point[0], point[1]))
+                else:
+                    wire_points.append(point)
+        elif start is not None and end is not None:
+            # Simple 2-point wire
+            if isinstance(start, tuple):
+                start = Point(start[0], start[1])
+            if isinstance(end, tuple):
+                end = Point(end[0], end[1])
+            wire_points = [start, end]
+        else:
+            raise ValueError("Must provide either start/end points or points list")
+
+        # Validate wire has at least 2 points
+        if len(wire_points) < 2:
+            raise ValueError("Wire must have at least 2 points")
+
+        # Create wire
+        wire = Wire(uuid=uuid, points=wire_points, wire_type=wire_type, stroke_width=stroke_width)
+
+        # Add to collection
+        super().add(wire)
+
+        logger.debug(f"Added wire: {len(wire_points)} points, UUID={uuid}")
+        return uuid
+
+    # Endpoint-based queries
+    def get_by_endpoint(
+        self, point: Union[Point, Tuple[float, float]], tolerance: float = 0.01
+    ) -> List[Wire]:
+        """
+        Find all wires with an endpoint near a given point.
+
+        Args:
+            point: Point to search for
+            tolerance: Distance tolerance for matching
+
+        Returns:
+            List of wires with endpoint near the point
+        """
+        if isinstance(point, tuple):
+            point = Point(point[0], point[1])
+
+        matching_wires = []
+        for wire in self._items:
+            # Check first and last point (endpoints)
+            if (wire.points[0].distance_to(point) <= tolerance or
+                wire.points[-1].distance_to(point) <= tolerance):
+                matching_wires.append(wire)
+
+        return matching_wires
+
+    def get_at_point(
+        self, point: Union[Point, Tuple[float, float]], tolerance: float = 0.01
+    ) -> List[Wire]:
+        """
+        Find all wires that pass through or near a point.
+
+        Args:
+            point: Point to search for
+            tolerance: Distance tolerance for matching
+
+        Returns:
+            List of wires passing through the point
+        """
+        if isinstance(point, tuple):
+            point = Point(point[0], point[1])
+
+        matching_wires = []
+        for wire in self._items:
+            # Check if any point in wire is near the search point
+            for wire_point in wire.points:
+                if wire_point.distance_to(point) <= tolerance:
+                    matching_wires.append(wire)
+                    break  # Found match, move to next wire
+
+        return matching_wires
+
+    # Wire geometry queries
+    def get_horizontal(self) -> List[Wire]:
+        """
+        Get all horizontal wires (Y coordinates equal).
+
+        Returns:
+            List of horizontal wires
+        """
+        horizontal = []
+        for wire in self._items:
+            if len(wire.points) == 2:
+                # Simple 2-point wire
+                if abs(wire.points[0].y - wire.points[1].y) < 0.01:
+                    horizontal.append(wire)
+
+        return horizontal
+
+    def get_vertical(self) -> List[Wire]:
+        """
+        Get all vertical wires (X coordinates equal).
+
+        Returns:
+            List of vertical wires
+        """
+        vertical = []
+        for wire in self._items:
+            if len(wire.points) == 2:
+                # Simple 2-point wire
+                if abs(wire.points[0].x - wire.points[1].x) < 0.01:
+                    vertical.append(wire)
+
+        return vertical
+
+    def get_by_type(self, wire_type: WireType) -> List[Wire]:
+        """
+        Get all wires of a specific type.
+
+        Args:
+            wire_type: Wire type to filter by
+
+        Returns:
+            List of wires matching the type
+        """
+        return [w for w in self._items if w.wire_type == wire_type]
+
+    # Statistics
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        Get wire collection statistics.
+
+        Returns:
+            Dictionary with wire statistics
+        """
+        if not self._items:
+            base_stats = super().get_statistics()
+            base_stats.update({
+                "total_wires": 0,
+                "total_segments": 0,
+                "wire_count": 0,
+                "bus_count": 0,
+                "horizontal_count": 0,
+                "vertical_count": 0,
+                "avg_points_per_wire": 0,
+            })
+            return base_stats
+
+        wire_count = sum(1 for w in self._items if w.wire_type == WireType.WIRE)
+        bus_count = sum(1 for w in self._items if w.wire_type == WireType.BUS)
+        total_segments = sum(len(w.points) - 1 for w in self._items)
+        avg_points = sum(len(w.points) for w in self._items) / len(self._items)
+
+        horizontal = len(self.get_horizontal())
+        vertical = len(self.get_vertical())
+
+        base_stats = super().get_statistics()
+        base_stats.update({
+            "total_wires": len(self._items),
+            "total_segments": total_segments,
+            "wire_count": wire_count,
+            "bus_count": bus_count,
+            "horizontal_count": horizontal,
+            "vertical_count": vertical,
+            "avg_points_per_wire": avg_points,
+        })
+
+        return base_stats
+
+    # Compatibility methods
+    @property
+    def modified(self) -> bool:
+        """Check if collection has been modified (compatibility)."""
+        return self.is_modified
+
+    def mark_saved(self) -> None:
+        """Mark collection as saved (reset modified flag)."""
+        self.mark_clean()

kicad_sch_api/core/__init__.py

@@ -1,10 +1,28 @@
 """Core kicad-sch-api functionality."""
 
-from .components import Component, ComponentCollection
+from ..collections import Component, ComponentCollection
 from .formatter import ExactFormatter
 from .parser import SExpressionParser
 from .schematic import Schematic, create_schematic, load_schematic
-from .types import Junction, Label, Net, Point, SchematicSymbol, Wire
+from .types import Junction, Label, Net, PinInfo, Point, SchematicSymbol, Wire
+# Exception hierarchy
+from .exceptions import (
+    KiCadSchError,
+    ValidationError,
+    ReferenceError,
+    LibraryError,
+    GeometryError,
+    NetError,
+    ParseError,
+    FormatError,
+    CollectionError,
+    ElementNotFoundError,
+    DuplicateElementError,
+    CollectionOperationError,
+    FileOperationError,
+    CLIError,
+    SchematicStateError,
+)
 
 __all__ = [
     "Schematic",
@@ -16,8 +34,25 @@ __all__ = [
     "Junction",
     "Label",
     "Net",
+    "PinInfo",
     "SExpressionParser",
     "ExactFormatter",
     "load_schematic",
     "create_schematic",
+    # Exceptions
+    "KiCadSchError",
+    "ValidationError",
+    "ReferenceError",
+    "LibraryError",
+    "GeometryError",
+    "NetError",
+    "ParseError",
+    "FormatError",
+    "CollectionError",
+    "ElementNotFoundError",
+    "DuplicateElementError",
+    "CollectionOperationError",
+    "FileOperationError",
+    "CLIError",
+    "SchematicStateError",
 ]

kicad_sch_api/core/collections/__init__.py

@@ -0,0 +1,5 @@
+"""Collection base classes for schematic elements."""
+
+from .base import BaseCollection
+
+__all__ = ["BaseCollection"]

kicad_sch_api/core/collections/base.py

@@ -0,0 +1,248 @@
+"""
+Base collection class for schematic elements.
+
+Provides common functionality for all collection types including UUID indexing,
+modification tracking, and standard collection operations.
+"""
+
+import logging
+from typing import Any, Callable, Dict, Generic, Iterator, List, Optional, Protocol, TypeVar
+
+logger = logging.getLogger(__name__)
+
+
+class HasUUID(Protocol):
+    """Protocol for objects that have a UUID attribute."""
+
+    @property
+    def uuid(self) -> str:
+        """UUID of the object."""
+        ...
+
+
+T = TypeVar("T", bound=HasUUID)
+
+
+class BaseCollection(Generic[T]):
+    """
+    Generic base class for schematic element collections.
+
+    Provides common functionality:
+    - UUID-based indexing for fast lookup
+    - Modification tracking
+    - Standard collection operations (__len__, __iter__, __getitem__)
+    - Index rebuilding and management
+
+    Type parameter T must implement the HasUUID protocol.
+    """
+
+    def __init__(self, items: Optional[List[T]] = None, collection_name: str = "items") -> None:
+        """
+        Initialize base collection.
+
+        Args:
+            items: Initial list of items
+            collection_name: Name for logging (e.g., "wires", "junctions")
+        """
+        self._items: List[T] = items or []
+        self._uuid_index: Dict[str, int] = {}
+        self._modified = False
+        self._collection_name = collection_name
+
+        # Build UUID index
+        self._rebuild_index()
+
+        logger.debug(f"{collection_name} collection initialized with {len(self._items)} items")
+
+    def _rebuild_index(self) -> None:
+        """Rebuild UUID index for fast lookups."""
+        self._uuid_index = {item.uuid: i for i, item in enumerate(self._items)}
+
+    def _mark_modified(self) -> None:
+        """Mark collection as modified."""
+        self._modified = True
+
+    def is_modified(self) -> bool:
+        """Check if collection has been modified."""
+        return self._modified
+
+    def reset_modified_flag(self) -> None:
+        """Reset modified flag (typically after save)."""
+        self._modified = False
+
+    # Standard collection protocol methods
+    def __len__(self) -> int:
+        """Return number of items in collection."""
+        return len(self._items)
+
+    def __iter__(self) -> Iterator[T]:
+        """Iterate over items in collection."""
+        return iter(self._items)
+
+    def __getitem__(self, key: Any) -> T:
+        """
+        Get item by UUID or index.
+
+        Args:
+            key: UUID string or integer index
+
+        Returns:
+            Item at the specified location
+
+        Raises:
+            KeyError: If UUID not found
+            IndexError: If index out of range
+            TypeError: If key is neither string nor int
+        """
+        if isinstance(key, str):
+            # UUID lookup
+            if key not in self._uuid_index:
+                raise KeyError(f"Item with UUID '{key}' not found")
+            return self._items[self._uuid_index[key]]
+        elif isinstance(key, int):
+            # Index lookup
+            return self._items[key]
+        else:
+            raise TypeError(f"Key must be string (UUID) or int (index), got {type(key)}")
+
+    def __contains__(self, key: Any) -> bool:
+        """
+        Check if item exists in collection.
+
+        Args:
+            key: UUID string or item object
+
+        Returns:
+            True if item exists
+        """
+        if isinstance(key, str):
+            return key in self._uuid_index
+        elif hasattr(key, "uuid"):
+            return key.uuid in self._uuid_index
+        return False
+
+    def get(self, uuid: str) -> Optional[T]:
+        """
+        Get item by UUID.
+
+        Args:
+            uuid: Item UUID
+
+        Returns:
+            Item if found, None otherwise
+        """
+        if uuid not in self._uuid_index:
+            return None
+        return self._items[self._uuid_index[uuid]]
+
+    def remove(self, uuid: str) -> bool:
+        """
+        Remove item by UUID.
+
+        Args:
+            uuid: UUID of item to remove
+
+        Returns:
+            True if item was removed, False if not found
+        """
+        if uuid not in self._uuid_index:
+            return False
+
+        index = self._uuid_index[uuid]
+        del self._items[index]
+        self._rebuild_index()
+        self._mark_modified()
+
+        logger.debug(f"Removed item with UUID {uuid} from {self._collection_name}")
+        return True
+
+    def clear(self) -> None:
+        """Remove all items from collection."""
+        self._items.clear()
+        self._uuid_index.clear()
+        self._mark_modified()
+        logger.debug(f"Cleared all items from {self._collection_name}")
+
+    def find(self, predicate: Callable[[T], bool]) -> List[T]:
+        """
+        Find all items matching a predicate.
+
+        Args:
+            predicate: Function that returns True for matching items
+
+        Returns:
+            List of matching items
+        """
+        return [item for item in self._items if predicate(item)]
+
+    def filter(self, **criteria) -> List[T]:
+        """
+        Filter items by attribute values.
+
+        Args:
+            **criteria: Attribute name/value pairs to match
+
+        Returns:
+            List of matching items
+
+        Example:
+            collection.filter(wire_type=WireType.BUS, stroke_width=0.5)
+        """
+        matches = []
+        for item in self._items:
+            if all(getattr(item, key, None) == value for key, value in criteria.items()):
+                matches.append(item)
+        return matches
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        Get collection statistics.
+
+        Returns:
+            Dictionary with statistics
+        """
+        return {
+            "total_items": len(self._items),
+            "modified": self._modified,
+            "indexed_items": len(self._uuid_index),
+        }
+
+    def _add_item(self, item: T) -> None:
+        """
+        Add item to internal storage and index.
+
+        Args:
+            item: Item to add
+
+        Raises:
+            ValueError: If item UUID already exists
+        """
+        if item.uuid in self._uuid_index:
+            raise ValueError(f"Item with UUID '{item.uuid}' already exists")
+
+        self._items.append(item)
+        self._uuid_index[item.uuid] = len(self._items) - 1
+        self._mark_modified()
+
+    def bulk_update(self, criteria: Dict[str, Any], updates: Dict[str, Any]) -> int:
+        """
+        Update multiple items matching criteria.
+
+        Args:
+            criteria: Attribute name/value pairs to match
+            updates: Attribute name/value pairs to update
+
+        Returns:
+            Number of items updated
+        """
+        matching_items = self.filter(**criteria)
+        for item in matching_items:
+            for key, value in updates.items():
+                if hasattr(item, key):
+                    setattr(item, key, value)
+
+        if matching_items:
+            self._mark_modified()
+
+        logger.debug(f"Bulk updated {len(matching_items)} items in {self._collection_name}")
+        return len(matching_items)

kicad_sch_api/core/component_bounds.py

@@ -382,16 +382,43 @@ def get_component_bounding_box(
     # Calculate symbol bounding box
     symbol_bbox = SymbolBoundingBoxCalculator.calculate_bounding_box(symbol, include_properties)
 
-    # Transform to world coordinates
-    # TODO: Handle component rotation in the future
+    # Transform to world coordinates with rotation
+    # Apply rotation matrix to bounding box corners, then find new min/max
+    import math
+
+    angle_rad = math.radians(component.rotation)
+    cos_a = math.cos(angle_rad)
+    sin_a = math.sin(angle_rad)
+
+    # Get all 4 corners of the symbol bounding box
+    corners = [
+        (symbol_bbox.min_x, symbol_bbox.min_y),  # Bottom-left
+        (symbol_bbox.max_x, symbol_bbox.min_y),  # Bottom-right
+        (symbol_bbox.max_x, symbol_bbox.max_y),  # Top-right
+        (symbol_bbox.min_x, symbol_bbox.max_y),  # Top-left
+    ]
+
+    # Rotate each corner using standard 2D rotation matrix
+    rotated_corners = []
+    for x, y in corners:
+        rotated_x = x * cos_a - y * sin_a
+        rotated_y = x * sin_a + y * cos_a
+        rotated_corners.append((rotated_x, rotated_y))
+
+    # Find min/max of rotated corners
+    rotated_xs = [x for x, y in rotated_corners]
+    rotated_ys = [y for x, y in rotated_corners]
+
     world_bbox = BoundingBox(
-        component.position.x + symbol_bbox.min_x,
-        component.position.y + symbol_bbox.min_y,
-        component.position.x + symbol_bbox.max_x,
-        component.position.y + symbol_bbox.max_y,
+        component.position.x + min(rotated_xs),
+        component.position.y + min(rotated_ys),
+        component.position.x + max(rotated_xs),
+        component.position.y + max(rotated_ys),
     )
 
-    logger.debug(f"Component {component.reference} world bbox: {world_bbox}")
+    logger.debug(
+        f"Component {component.reference} at {component.rotation}° world bbox: {world_bbox}"
+    )
     return world_bbox