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

kicad_sch_api/core/texts.py

@@ -0,0 +1,343 @@
+"""
+Text element management for KiCAD schematics.
+
+This module provides collection classes for managing text 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, Text
+
+logger = logging.getLogger(__name__)
+
+
+class TextElement:
+    """
+    Enhanced wrapper for schematic text elements with modern API.
+
+    Provides intuitive access to text properties and operations
+    while maintaining exact format preservation.
+    """
+
+    def __init__(self, text_data: Text, parent_collection: "TextCollection"):
+        """
+        Initialize text element wrapper.
+
+        Args:
+            text_data: Underlying text data
+            parent_collection: Parent collection for updates
+        """
+        self._data = text_data
+        self._collection = parent_collection
+        self._validator = SchematicValidator()
+
+    # Core properties with validation
+    @property
+    def uuid(self) -> str:
+        """Text element UUID."""
+        return self._data.uuid
+
+    @property
+    def text(self) -> str:
+        """Text content."""
+        return self._data.text
+
+    @text.setter
+    def text(self, value: str):
+        """Set text content with validation."""
+        if not isinstance(value, str):
+            raise ValidationError(f"Text content must be string, got {type(value)}")
+        self._data.text = value
+        self._collection._mark_modified()
+
+    @property
+    def position(self) -> Point:
+        """Text position."""
+        return self._data.position
+
+    @position.setter
+    def position(self, value: Union[Point, Tuple[float, float]]):
+        """Set text 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()
+
+    @property
+    def rotation(self) -> float:
+        """Text rotation in degrees."""
+        return self._data.rotation
+
+    @rotation.setter
+    def rotation(self, value: float):
+        """Set text rotation."""
+        self._data.rotation = float(value)
+        self._collection._mark_modified()
+
+    @property
+    def size(self) -> float:
+        """Text size."""
+        return self._data.size
+
+    @size.setter
+    def size(self, value: float):
+        """Set text size with validation."""
+        if value <= 0:
+            raise ValidationError(f"Text size must be positive, got {value}")
+        self._data.size = float(value)
+        self._collection._mark_modified()
+
+    @property
+    def exclude_from_sim(self) -> bool:
+        """Whether text is excluded from simulation."""
+        return self._data.exclude_from_sim
+
+    @exclude_from_sim.setter
+    def exclude_from_sim(self, value: bool):
+        """Set exclude from simulation flag."""
+        self._data.exclude_from_sim = bool(value)
+        self._collection._mark_modified()
+
+    def validate(self) -> List[ValidationIssue]:
+        """Validate this text element."""
+        return self._validator.validate_text(self._data.__dict__)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert text element to dictionary representation."""
+        return {
+            "uuid": self.uuid,
+            "text": self.text,
+            "position": {"x": self.position.x, "y": self.position.y},
+            "rotation": self.rotation,
+            "size": self.size,
+            "exclude_from_sim": self.exclude_from_sim,
+        }
+
+    def __str__(self) -> str:
+        """String representation."""
+        return f"<Text '{self.text}' @ {self.position}>"
+
+
+class TextCollection:
+    """
+    Collection class for efficient text element management.
+
+    Provides fast lookup, filtering, and bulk operations for schematic text elements.
+    """
+
+    def __init__(self, texts: List[Text] = None):
+        """
+        Initialize text collection.
+
+        Args:
+            texts: Initial list of text data
+        """
+        self._texts: List[TextElement] = []
+        self._uuid_index: Dict[str, TextElement] = {}
+        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,
+        position: Union[Point, Tuple[float, float]],
+        rotation: float = 0.0,
+        size: float = 1.27,
+        exclude_from_sim: bool = False,
+        text_uuid: Optional[str] = None,
+    ) -> TextElement:
+        """
+        Add a new text element to the schematic.
+
+        Args:
+            text: Text content
+            position: Text position
+            rotation: Text rotation in degrees
+            size: Text size
+            exclude_from_sim: Whether to exclude from simulation
+            text_uuid: Specific UUID for text (auto-generated if None)
+
+        Returns:
+            Newly created TextElement
+
+        Raises:
+            ValidationError: If text data is invalid
+        """
+        # Validate inputs
+        if not isinstance(text, str) or not text.strip():
+            raise ValidationError("Text content cannot be empty")
+
+        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)}")
+
+        if size <= 0:
+            raise ValidationError(f"Text size must be positive, got {size}")
+
+        # Generate UUID if not provided
+        if not text_uuid:
+            text_uuid = str(uuid.uuid4())
+
+        # Check for duplicate UUID
+        if text_uuid in self._uuid_index:
+            raise ValidationError(f"Text UUID {text_uuid} already exists")
+
+        # Create text data
+        text_data = Text(
+            uuid=text_uuid,
+            position=position,
+            text=text,
+            rotation=rotation,
+            size=size,
+            exclude_from_sim=exclude_from_sim,
+        )
+
+        # 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.
+
+        Args:
+            text_uuid: UUID of text to remove
+
+        Returns:
+            True if text was removed, False if not found
+        """
+        text_element = self._uuid_index.get(text_uuid)
+        if not text_element:
+            return False
+
+        # Remove from indexes
+        self._remove_from_indexes(text_element)
+        self._mark_modified()
+
+        logger.debug(f"Removed text: {text_element}")
+        return True
+
+    def find_by_content(self, content: str, exact: bool = True) -> List[TextElement]:
+        """
+        Find texts by content.
+
+        Args:
+            content: Content to search for
+            exact: If True, exact match; if False, substring match
+
+        Returns:
+            List of matching text elements
+        """
+        if exact:
+            return self._content_index.get(content, []).copy()
+        else:
+            matches = []
+            for text_element in self._texts:
+                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.
+
+        Args:
+            predicate: Function that returns True for texts to include
+
+        Returns:
+            List of texts matching predicate
+        """
+        return [text for text in self._texts if predicate(text)]
+
+    def bulk_update(self, criteria: Callable[[TextElement], bool], updates: Dict[str, Any]):
+        """
+        Update multiple texts matching criteria.
+
+        Args:
+            criteria: Function to select texts to update
+            updates: Dictionary of property updates
+        """
+        updated_count = 0
+        for text_element in self._texts:
+            if criteria(text_element):
+                for prop, value in updates.items():
+                    if hasattr(text_element, prop):
+                        setattr(text_element, prop, value)
+                        updated_count += 1
+
+        if updated_count > 0:
+            self._mark_modified()
+            logger.debug(f"Bulk updated {updated_count} text properties")
+
+    def clear(self):
+        """Remove all texts from collection."""
+        self._texts.clear()
+        self._uuid_index.clear()
+        self._content_index.clear()
+        self._mark_modified()
+
+    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 to content index
+        content = text_element.text
+        if content not in self._content_index:
+            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]
+
+    def __bool__(self) -> bool:
+        """Return True if collection has texts."""
+        return len(self._texts) > 0

kicad_sch_api/core/types.py

@@ -366,10 +366,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
@@ -386,6 +383,18 @@ class Image:
             self.uuid = str(uuid4())
 
 
+@dataclass
+class NoConnect:
+    """No-connect symbol in schematic."""
+
+    uuid: str
+    position: Point
+
+    def __post_init__(self):
+        if not self.uuid:
+            self.uuid = str(uuid4())
+
+
 @dataclass
 class Net:
     """Electrical net connecting components."""

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)
+)

kicad_sch_api/geometry/symbol_bbox.py

@@ -59,12 +59,9 @@ class SymbolBoundingBoxCalculator:
         if not symbol_data:
             raise ValueError("Symbol data is None or empty")
 
-        import sys
-        # Reduced logging frequency - only log if DEBUG environment variable is set
-        debug_enabled = os.getenv("CIRCUIT_SYNTH_DEBUG", "").lower() == "true"
-        if debug_enabled:
-            print(f"\n=== CALCULATING BOUNDING BOX ===", file=sys.stderr, flush=True)
-            print(f"include_properties={include_properties}", file=sys.stderr, flush=True)
+        # Use proper logging instead of print statements
+        logger.debug("=== CALCULATING BOUNDING BOX ===")
+        logger.debug(f"include_properties={include_properties}")
 
         min_x = float("inf")
         min_y = float("inf")
@@ -73,7 +70,7 @@ class SymbolBoundingBoxCalculator:
 
         # Process main symbol shapes (handle both 'shapes' and 'graphics' keys)
         shapes = symbol_data.get("shapes", []) or symbol_data.get("graphics", [])
-        print(f"Processing {len(shapes)} main shapes", file=sys.stderr, flush=True)
+        logger.debug(f"Processing {len(shapes)} main shapes")
         for shape in shapes:
             shape_bounds = cls._get_shape_bounds(shape)
             if shape_bounds:
@@ -85,7 +82,7 @@ class SymbolBoundingBoxCalculator:
 
         # Process pins (including their labels)
         pins = symbol_data.get("pins", [])
-        print(f"Processing {len(pins)} main pins", file=sys.stderr, flush=True)
+        logger.debug(f"Processing {len(pins)} main pins")
         for pin in pins:
             pin_bounds = cls._get_pin_bounds(pin, pin_net_map)
             if pin_bounds:
@@ -123,8 +120,10 @@ class SymbolBoundingBoxCalculator:
         if min_x == float("inf") or max_x == float("-inf"):
             raise ValueError(f"No valid geometry found in symbol data")
 
-        print(f"After geometry processing: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})", file=sys.stderr, flush=True)
-        print(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}", file=sys.stderr, flush=True)
+        logger.debug(
+            f"After geometry processing: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})"
+        )
+        logger.debug(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}")
 
         # Add small margin for text that might extend beyond shapes
         margin = 0.254  # 10 mils
@@ -162,9 +161,9 @@ class SymbolBoundingBoxCalculator:
             f"Calculated bounding box: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})"
         )
 
-        print(f"FINAL BBOX: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})", file=sys.stderr, flush=True)
-        print(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}", file=sys.stderr, flush=True)
-        print("=" * 50 + "\n", file=sys.stderr, flush=True)
+        logger.debug(f"FINAL BBOX: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})")
+        logger.debug(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}")
+        logger.debug("=" * 50)
 
         return (min_x, min_y, max_x, max_y)
 
@@ -196,8 +195,7 @@ class SymbolBoundingBoxCalculator:
         if not symbol_data:
             raise ValueError("Symbol data is None or empty")
 
-        import sys
-        print(f"\n=== CALCULATING PLACEMENT BOUNDING BOX (NO PIN LABELS) ===", file=sys.stderr, flush=True)
+        logger.debug("=== CALCULATING PLACEMENT BOUNDING BOX (NO PIN LABELS) ===")
 
         min_x = float("inf")
         min_y = float("inf")
@@ -206,7 +204,7 @@ class SymbolBoundingBoxCalculator:
 
         # Process main symbol shapes (handle both 'shapes' and 'graphics' keys)
         shapes = symbol_data.get("shapes", []) or symbol_data.get("graphics", [])
-        print(f"Processing {len(shapes)} main shapes", file=sys.stderr, flush=True)
+        logger.debug(f"Processing {len(shapes)} main shapes")
         for shape in shapes:
             shape_bounds = cls._get_shape_bounds(shape)
             if shape_bounds:
@@ -218,7 +216,7 @@ class SymbolBoundingBoxCalculator:
 
         # Process pins WITHOUT labels (just pin endpoints)
         pins = symbol_data.get("pins", [])
-        print(f"Processing {len(pins)} main pins (NO LABELS)", file=sys.stderr, flush=True)
+        logger.debug(f"Processing {len(pins)} main pins (NO LABELS)")
         for pin in pins:
             pin_bounds = cls._get_pin_bounds_no_labels(pin)
             if pin_bounds:
@@ -256,8 +254,10 @@ class SymbolBoundingBoxCalculator:
         if min_x == float("inf") or max_x == float("-inf"):
             raise ValueError(f"No valid geometry found in symbol data")
 
-        print(f"After geometry processing: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})", file=sys.stderr, flush=True)
-        print(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}", file=sys.stderr, flush=True)
+        logger.debug(
+            f"After geometry processing: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})"
+        )
+        logger.debug(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}")
 
         # Add small margin for visual spacing
         margin = 0.635  # 25mil margin (reduced from 50mil)
@@ -269,14 +269,18 @@ class SymbolBoundingBoxCalculator:
         # Add minimal space for component properties (Reference above, Value below)
         # Use adaptive spacing based on component height for better visual hierarchy
         component_height = max_y - min_y
-        property_spacing = max(3.0, component_height * 0.15)  # Adaptive: minimum 3mm or 15% of height
+        property_spacing = max(
+            3.0, component_height * 0.15
+        )  # Adaptive: minimum 3mm or 15% of height
         property_height = 1.27  # Reduced from 2.54mm
         min_y -= property_spacing + property_height  # Reference above
         max_y += property_spacing + property_height  # Value below
 
-        print(f"FINAL PLACEMENT BBOX: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})", file=sys.stderr, flush=True)
-        print(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}", file=sys.stderr, flush=True)
-        print("=" * 50 + "\n", file=sys.stderr, flush=True)
+        logger.debug(
+            f"FINAL PLACEMENT BBOX: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})"
+        )
+        logger.debug(f"  Width: {max_x - min_x:.2f}, Height: {max_y - min_y:.2f}")
+        logger.debug("=" * 50)
 
         return (min_x, min_y, max_x, max_y)
 
@@ -363,7 +367,10 @@ class SymbolBoundingBoxCalculator:
 
     @classmethod
     def get_symbol_dimensions(
-        cls, symbol_data: Dict[str, Any], include_properties: bool = True, pin_net_map: Optional[Dict[str, str]] = None
+        cls,
+        symbol_data: Dict[str, Any],
+        include_properties: bool = True,
+        pin_net_map: Optional[Dict[str, str]] = None,
     ) -> Tuple[float, float]:
         """
         Get the width and height of a symbol.
@@ -459,7 +466,6 @@ class SymbolBoundingBoxCalculator:
         cls, pin: Dict[str, Any], pin_net_map: Optional[Dict[str, str]] = None
     ) -> Optional[Tuple[float, float, float, float]]:
         """Get bounding box for a pin including its labels."""
-        import sys
 
         # Handle both formats: 'at' array or separate x/y/orientation
         if "at" in pin:
@@ -493,24 +499,28 @@ class SymbolBoundingBoxCalculator:
         # If no net name match, use minimal fallback to avoid oversized bounding boxes
         if pin_net_map and pin_number in pin_net_map:
             label_text = pin_net_map[pin_number]
-            print(f"  PIN {pin_number}: ✅ USING NET '{label_text}' (len={len(label_text)}), at=({x:.2f}, {y:.2f}), angle={angle}", file=sys.stderr, flush=True)
+            logger.debug(
+                f"  PIN {pin_number}: ✅ USING NET '{label_text}' (len={len(label_text)}), at=({x:.2f}, {y:.2f}), angle={angle}"
+            )
         else:
             # No net match - use minimal size (3 chars) instead of potentially long pin name
             label_text = "XXX"  # 3-character placeholder for unmatched pins
-            print(f"  PIN {pin_number}: ⚠️  NO MATCH, using minimal fallback (pin name was '{pin_name}'), at=({x:.2f}, {y:.2f})", file=sys.stderr, flush=True)
+            logger.debug(
+                f"  PIN {pin_number}: ⚠️  NO MATCH, using minimal fallback (pin name was '{pin_name}'), at=({x:.2f}, {y:.2f})"
+            )
 
         if label_text and label_text != "~":  # ~ means no name
             # Calculate text dimensions
             # For horizontal text: width = char_count * char_width
             name_width = (
-                len(label_text)
-                * cls.DEFAULT_TEXT_HEIGHT
-                * cls.DEFAULT_PIN_TEXT_WIDTH_RATIO
+                len(label_text) * cls.DEFAULT_TEXT_HEIGHT * cls.DEFAULT_PIN_TEXT_WIDTH_RATIO
             )
             # For vertical text: height = char_count * char_height (characters stack vertically)
             name_height = len(label_text) * cls.DEFAULT_TEXT_HEIGHT
 
-            print(f"    label_width={name_width:.2f}, label_height={name_height:.2f} (len={len(label_text)})", file=sys.stderr, flush=True)
+            logger.debug(
+                f"    label_width={name_width:.2f}, label_height={name_height:.2f} (len={len(label_text)})"
+            )
 
             # Adjust bounds based on pin orientation
             # Labels are placed at PIN ENDPOINT with offset, extending AWAY from the component
@@ -520,38 +530,42 @@ class SymbolBoundingBoxCalculator:
 
             if angle == 0:  # Pin points right - label extends LEFT from endpoint
                 label_x = end_x - offset - name_width
-                print(f"    Angle 0 (Right pin): min_x {min_x:.2f} -> {label_x:.2f} (offset={offset:.3f})", file=sys.stderr, flush=True)
+                logger.debug(
+                    f"    Angle 0 (Right pin): min_x {min_x:.2f} -> {label_x:.2f} (offset={offset:.3f})"
+                )
                 min_x = min(min_x, label_x)
             elif angle == 180:  # Pin points left - label extends RIGHT from endpoint
                 label_x = end_x + offset + name_width
-                print(f"    Angle 180 (Left pin): max_x {max_x:.2f} -> {label_x:.2f} (offset={offset:.3f})", file=sys.stderr, flush=True)
+                logger.debug(
+                    f"    Angle 180 (Left pin): max_x {max_x:.2f} -> {label_x:.2f} (offset={offset:.3f})"
+                )
                 max_x = max(max_x, label_x)
             elif angle == 90:  # Pin points up - label extends DOWN from endpoint
                 label_y = end_y - offset - name_height
-                print(f"    Angle 90 (Up pin): min_y {min_y:.2f} -> {label_y:.2f} (offset={offset:.3f})", file=sys.stderr, flush=True)
+                logger.debug(
+                    f"    Angle 90 (Up pin): min_y {min_y:.2f} -> {label_y:.2f} (offset={offset:.3f})"
+                )
                 min_y = min(min_y, label_y)
             elif angle == 270:  # Pin points down - label extends UP from endpoint
                 label_y = end_y + offset + name_height
-                print(f"    Angle 270 (Down pin): max_y {max_y:.2f} -> {label_y:.2f} (offset={offset:.3f})", file=sys.stderr, flush=True)
+                logger.debug(
+                    f"    Angle 270 (Down pin): max_y {max_y:.2f} -> {label_y:.2f} (offset={offset:.3f})"
+                )
                 max_y = max(max_y, label_y)
 
         # Pin numbers are typically placed near the component body
         if pin_number:
             num_width = (
-                len(pin_number)
-                * cls.DEFAULT_PIN_NUMBER_SIZE
-                * cls.DEFAULT_PIN_TEXT_WIDTH_RATIO
+                len(pin_number) * cls.DEFAULT_PIN_NUMBER_SIZE * cls.DEFAULT_PIN_TEXT_WIDTH_RATIO
             )
             # Add some space for the pin number
-            margin = (
-                cls.DEFAULT_PIN_NUMBER_SIZE * 1.5
-            )  # Increase margin for better spacing
+            margin = cls.DEFAULT_PIN_NUMBER_SIZE * 1.5  # Increase margin for better spacing
             min_x -= margin
             min_y -= margin
             max_x += margin
             max_y += margin
 
-        print(f"    Pin bounds: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})", file=sys.stderr, flush=True)
+        logger.debug(f"    Pin bounds: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})")
         return (min_x, min_y, max_x, max_y)
 
     @classmethod
@@ -559,7 +573,6 @@ class SymbolBoundingBoxCalculator:
         cls, pin: Dict[str, Any]
     ) -> Optional[Tuple[float, float, float, float]]:
         """Get bounding box for a pin WITHOUT labels - for placement calculations only."""
-        import sys
 
         # Handle both formats: 'at' array or separate x/y/orientation
         if "at" in pin:

kicad_sch_api/interfaces/__init__.py

@@ -0,0 +1,17 @@
+"""
+Core interfaces for KiCAD schematic API.
+
+This module provides abstract interfaces for the main components of the system,
+enabling better separation of concerns and testability.
+"""
+
+from .parser import IElementParser, ISchematicParser
+from .repository import ISchematicRepository
+from .resolver import ISymbolResolver
+
+__all__ = [
+    "IElementParser",
+    "ISchematicParser",
+    "ISchematicRepository",
+    "ISymbolResolver",
+]