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

kicad_sch_api/core/texts.py

@@ -340,4 +340,4 @@ class TextCollection:
 
     def __bool__(self) -> bool:
         """Return True if collection has texts."""
-        return len(self._texts) > 0
+        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

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

@@ -120,7 +120,9 @@ class SymbolBoundingBoxCalculator:
         if min_x == float("inf") or max_x == float("-inf"):
             raise ValueError(f"No valid geometry found in symbol data")
 
-        logger.debug(f"After geometry processing: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})")
+        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
@@ -252,7 +254,9 @@ class SymbolBoundingBoxCalculator:
         if min_x == float("inf") or max_x == float("-inf"):
             raise ValueError(f"No valid geometry found in symbol data")
 
-        logger.debug(f"After geometry processing: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})")
+        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
@@ -265,12 +269,16 @@ 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
 
-        logger.debug(f"FINAL PLACEMENT BBOX: ({min_x:.2f}, {min_y:.2f}) to ({max_x:.2f}, {max_y:.2f})")
+        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)
 
@@ -359,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.
@@ -488,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]
-            logger.debug(f"  PIN {pin_number}: ✅ USING NET '{label_text}' (len={len(label_text)}), at=({x:.2f}, {y:.2f}), angle={angle}")
+            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
-            logger.debug(f"  PIN {pin_number}: ⚠️  NO MATCH, using minimal fallback (pin name was '{pin_name}'), at=({x:.2f}, {y:.2f})")
+            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
 
-            logger.debug(f"    label_width={name_width:.2f}, label_height={name_height:.2f} (len={len(label_text)})")
+            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
@@ -515,32 +530,36 @@ class SymbolBoundingBoxCalculator:
 
             if angle == 0:  # Pin points right - label extends LEFT from endpoint
                 label_x = end_x - offset - name_width
-                logger.debug(f"    Angle 0 (Right pin): min_x {min_x:.2f} -> {label_x:.2f} (offset={offset:.3f})")
+                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
-                logger.debug(f"    Angle 180 (Left pin): max_x {max_x:.2f} -> {label_x:.2f} (offset={offset:.3f})")
+                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
-                logger.debug(f"    Angle 90 (Up pin): min_y {min_y:.2f} -> {label_y:.2f} (offset={offset:.3f})")
+                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
-                logger.debug(f"    Angle 270 (Down pin): max_y {max_y:.2f} -> {label_y:.2f} (offset={offset:.3f})")
+                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

kicad_sch_api/interfaces/__init__.py

@@ -14,4 +14,4 @@ __all__ = [
     "ISchematicParser",
     "ISchematicRepository",
     "ISymbolResolver",
-]
+]

kicad_sch_api/interfaces/parser.py

@@ -73,4 +73,4 @@ class ISchematicParser(Protocol):
         Raises:
             ParseError: If content format is invalid
         """
-        ...
+        ...

kicad_sch_api/interfaces/repository.py

@@ -67,4 +67,4 @@ class ISchematicRepository(Protocol):
         Raises:
             FileNotFoundError: If file doesn't exist
         """
-        ...
+        ...

kicad_sch_api/interfaces/resolver.py

@@ -114,4 +114,4 @@ class ISymbolCache(Protocol):
         Returns:
             Dictionary with cache statistics (hits, misses, size, etc.)
         """
-        ...
+        ...

kicad_sch_api/parsers/__init__.py

@@ -5,10 +5,10 @@ This package provides specialized parsers for different types of KiCAD
 S-expression elements, organized by responsibility and testable in isolation.
 """
 
-from .registry import ElementParserRegistry
 from .base import BaseElementParser
+from .registry import ElementParserRegistry
 
 __all__ = [
     "ElementParserRegistry",
     "BaseElementParser",
-]
+]

kicad_sch_api/parsers/base.py

@@ -92,10 +92,7 @@ class BaseElementParser(IElementParser):
             return None
 
         try:
-            result = {
-                "x": float(element[1]),
-                "y": float(element[2])
-            }
+            result = {"x": float(element[1]), "y": float(element[2])}
 
             # Optional angle parameter
             if len(element) > 3:
@@ -105,7 +102,9 @@ class BaseElementParser(IElementParser):
         except (ValueError, IndexError):
             return None
 
-    def _extract_property_list(self, elements: List[Any], property_name: str) -> List[Dict[str, Any]]:
+    def _extract_property_list(
+        self, elements: List[Any], property_name: str
+    ) -> List[Dict[str, Any]]:
         """
         Extract all instances of a property from a list of elements.
 
@@ -118,9 +117,7 @@ class BaseElementParser(IElementParser):
         """
         properties = []
         for element in elements:
-            if (isinstance(element, list) and
-                len(element) > 0 and
-                element[0] == property_name):
+            if isinstance(element, list) and len(element) > 0 and element[0] == property_name:
                 prop = self._parse_property_element(element)
                 if prop:
                     properties.append(prop)
@@ -144,5 +141,5 @@ class BaseElementParser(IElementParser):
         return {
             "type": element[0],
             "value": element[1] if len(element) > 1 else None,
-            "raw": element
-        }
+            "raw": element,
+        }

kicad_sch_api/parsers/label_parser.py

@@ -46,9 +46,9 @@ class LabelParser(BaseElementParser):
                 "bold": False,
                 "italic": False,
                 "hide": False,
-                "justify": []
+                "justify": [],
             },
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in element[2:]:
@@ -99,7 +99,7 @@ class LabelParser(BaseElementParser):
             "bold": False,
             "italic": False,
             "hide": False,
-            "justify": []
+            "justify": [],
         }
 
         for elem in effects_element[1:]:
@@ -176,9 +176,9 @@ class HierarchicalLabelParser(BaseElementParser):
                 "bold": False,
                 "italic": False,
                 "hide": False,
-                "justify": []
+                "justify": [],
             },
-            "uuid": None
+            "uuid": None,
         }
 
         for elem in element[2:]:
@@ -217,7 +217,7 @@ class HierarchicalLabelParser(BaseElementParser):
             "bold": False,
             "italic": False,
             "hide": False,
-            "justify": []
+            "justify": [],
         }
 
         for elem in effects_element[1:]:
@@ -251,4 +251,4 @@ class HierarchicalLabelParser(BaseElementParser):
                 elif elem_type == "bold":
                     effects["bold"] = True
                 elif elem_type == "italic":
-                    effects["italic"] = True
+                    effects["italic"] = True

kicad_sch_api/parsers/registry.py

@@ -99,7 +99,9 @@ class ElementParserRegistry:
 
         # Try fallback parser
         if self._fallback_parser:
-            self._logger.debug(f"Using fallback parser for unknown element type: {element_type_str}")
+            self._logger.debug(
+                f"Using fallback parser for unknown element type: {element_type_str}"
+            )
             return self._fallback_parser.parse(element)
 
         # No parser available
@@ -150,4 +152,4 @@ class ElementParserRegistry:
         """Clear all registered parsers."""
         self._parsers.clear()
         self._fallback_parser = None
-        self._logger.debug("Cleared all registered parsers")
+        self._logger.debug("Cleared all registered parsers")

kicad_sch_api/parsers/symbol_parser.py

@@ -44,7 +44,7 @@ class SymbolParser(BaseElementParser):
             "fields_autoplaced": False,
             "uuid": None,
             "properties": [],
-            "instances": []
+            "instances": [],
         }
 
         for elem in element[1:]:
@@ -112,7 +112,7 @@ class SymbolParser(BaseElementParser):
             "name": str(prop_element[1]),
             "value": str(prop_element[2]),
             "position": {"x": 0, "y": 0, "angle": 0},
-            "effects": {}
+            "effects": {},
         }
 
         # Parse additional property elements
@@ -145,7 +145,7 @@ class SymbolParser(BaseElementParser):
             "bold": False,
             "italic": False,
             "hide": False,
-            "justify": []
+            "justify": [],
         }
 
         for elem in effects_element[1:]:
@@ -193,12 +193,7 @@ class SymbolParser(BaseElementParser):
 
     def _parse_instance(self, instance_element: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a single instance element."""
-        instance = {
-            "project": "",
-            "path": "",
-            "reference": "",
-            "unit": 1
-        }
+        instance = {"project": "", "path": "", "reference": "", "unit": 1}
 
         for elem in instance_element[1:]:
             if isinstance(elem, list) and len(elem) >= 2:
@@ -224,4 +219,4 @@ class SymbolParser(BaseElementParser):
         elif isinstance(value, sexpdata.Symbol):
             return str(value).lower() in ("yes", "true", "1")
         else:
-            return bool(value)
+            return bool(value)

kicad_sch_api/parsers/wire_parser.py

@@ -39,7 +39,7 @@ class WireParser(BaseElementParser):
             "stroke_width": 0.0,
             "stroke_type": "default",
             "uuid": None,
-            "wire_type": "wire"  # Default to wire (vs bus)
+            "wire_type": "wire",  # Default to wire (vs bus)
         }
 
         for elem in element[1:]:
@@ -96,4 +96,4 @@ class WireParser(BaseElementParser):
                     elif stroke_type == "type":
                         wire_data["stroke_type"] = str(stroke_elem[1])
                 except (ValueError, IndexError) as e:
-                    self._logger.warning(f"Invalid stroke property: {stroke_elem}, error: {e}")
+                    self._logger.warning(f"Invalid stroke property: {stroke_elem}, error: {e}")

kicad_sch_api/symbols/__init__.py

@@ -15,4 +15,4 @@ __all__ = [
     "SymbolCache",
     "SymbolResolver",
     "SymbolValidator",
-]
+]

kicad_sch_api/symbols/cache.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 import sexpdata
 
-from ..library.cache import SymbolDefinition, LibraryStats
+from ..library.cache import LibraryStats, SymbolDefinition
 from ..utils.validation import ValidationError
 
 logger = logging.getLogger(__name__)
@@ -199,7 +199,7 @@ class SymbolCache(ISymbolCache):
             library_path=library_path,
             file_size=stat.st_size,
             last_modified=stat.st_mtime,
-            symbol_count=0  # Will be updated when library is loaded
+            symbol_count=0,  # Will be updated when library is loaded
         )
 
         logger.info(f"Added library: {library_name} ({library_path})")
@@ -257,10 +257,10 @@ class SymbolCache(ISymbolCache):
                 name: {
                     "file_size": stats.file_size,
                     "symbols_count": stats.symbols_count,
-                    "last_loaded": stats.last_loaded
+                    "last_loaded": stats.last_loaded,
                 }
                 for name, stats in self._lib_stats.items()
-            }
+            },
         }
 
     # Private methods for implementation details
@@ -316,10 +316,7 @@ class SymbolCache(ISymbolCache):
         return None
 
     def _create_symbol_definition(
-        self,
-        symbol_data: List,
-        lib_id: str,
-        library_name: str
+        self, symbol_data: List, lib_id: str, library_name: str
     ) -> SymbolDefinition:
         """Create SymbolDefinition from parsed symbol data."""
         symbol_name = str(symbol_data[1]).strip('"')
@@ -345,7 +342,7 @@ class SymbolCache(ISymbolCache):
             power_symbol=properties.get("power_symbol", False),
             graphic_elements=graphic_elements,
             raw_kicad_data=symbol_data,
-            extends=extends  # Store extends information for resolver
+            extends=extends,  # Store extends information for resolver
         )
 
     def _extract_symbol_properties(self, symbol_data: List) -> Dict[str, Any]:
@@ -356,7 +353,7 @@ class SymbolCache(ISymbolCache):
             "keywords": "",
             "datasheet": "",
             "units": 1,
-            "power_symbol": False
+            "power_symbol": False,
         }
 
         for item in symbol_data[1:]:
@@ -446,7 +443,7 @@ class SymbolCache(ISymbolCache):
             index_data = {
                 "symbol_index": self._symbol_index,
                 "library_paths": [str(path) for path in self._library_paths],
-                "created": time.time()
+                "created": time.time(),
             }
 
             with open(self._index_file, "w") as f:
@@ -467,4 +464,4 @@ class SymbolCache(ISymbolCache):
                 if str(item[0]) == "symbol" and str(item[1]) == symbol_name:
                     return item
 
-        return None
+        return None

kicad_sch_api/symbols/resolver.py

@@ -86,7 +86,7 @@ class SymbolResolver:
         max_chain_length = 0
 
         for symbol in self._inheritance_cache.values():
-            if hasattr(symbol, '_inheritance_depth'):
+            if hasattr(symbol, "_inheritance_depth"):
                 inheritance_chains += 1
                 max_chain_length = max(max_chain_length, symbol._inheritance_depth)
 
@@ -94,7 +94,7 @@ class SymbolResolver:
             "resolved_symbols": len(self._inheritance_cache),
             "inheritance_chains": inheritance_chains,
             "max_chain_length": max_chain_length,
-            "cache_size": len(self._inheritance_cache)
+            "cache_size": len(self._inheritance_cache),
         }
 
     def _resolve_with_inheritance(self, symbol: SymbolDefinition) -> Optional[SymbolDefinition]:
@@ -112,7 +112,9 @@ class SymbolResolver:
 
         # Check for circular inheritance
         if symbol.lib_id in self._resolution_stack:
-            logger.error(f"Circular inheritance detected: {' -> '.join(self._resolution_stack + [symbol.lib_id])}")
+            logger.error(
+                f"Circular inheritance detected: {' -> '.join(self._resolution_stack + [symbol.lib_id])}"
+            )
             return None
 
         self._resolution_stack.append(symbol.lib_id)
@@ -136,7 +138,7 @@ class SymbolResolver:
             resolved_symbol = self._merge_parent_into_child(symbol, resolved_parent)
 
             # Track inheritance depth for statistics
-            parent_depth = getattr(resolved_parent, '_inheritance_depth', 0)
+            parent_depth = getattr(resolved_parent, "_inheritance_depth", 0)
             resolved_symbol._inheritance_depth = parent_depth + 1
 
             logger.debug(f"Resolved inheritance: {symbol.lib_id} extends {parent_lib_id}")
@@ -168,9 +170,7 @@ class SymbolResolver:
         return f"{current_library}:{parent_name}"
 
     def _merge_parent_into_child(
-        self,
-        child: SymbolDefinition,
-        parent: SymbolDefinition
+        self, child: SymbolDefinition, parent: SymbolDefinition
     ) -> SymbolDefinition:
         """
         Merge parent symbol into child symbol.
@@ -188,10 +188,7 @@ class SymbolResolver:
         # Merge raw KiCAD data for exact format preservation
         if child.raw_kicad_data and parent.raw_kicad_data:
             merged.raw_kicad_data = self._merge_kicad_data(
-                child.raw_kicad_data,
-                parent.raw_kicad_data,
-                child.name,
-                parent.name
+                child.raw_kicad_data, parent.raw_kicad_data, child.name, parent.name
             )
 
         # Merge other properties
@@ -204,11 +201,7 @@ class SymbolResolver:
         return merged
 
     def _merge_kicad_data(
-        self,
-        child_data: List,
-        parent_data: List,
-        child_name: str,
-        parent_name: str
+        self, child_data: List, parent_data: List, child_name: str, parent_name: str
     ) -> List:
         """
         Merge parent KiCAD data into child KiCAD data.
@@ -227,11 +220,10 @@ class SymbolResolver:
 
         # Remove extends directive from child
         merged = [
-            item for item in merged
+            item
+            for item in merged
             if not (
-                isinstance(item, list) and
-                len(item) >= 2 and
-                item[0] == sexpdata.Symbol("extends")
+                isinstance(item, list) and len(item) >= 2 and item[0] == sexpdata.Symbol("extends")
             )
         ]
 
@@ -255,9 +247,7 @@ class SymbolResolver:
         return merged
 
     def _merge_symbol_properties(
-        self,
-        child: SymbolDefinition,
-        parent: SymbolDefinition
+        self, child: SymbolDefinition, parent: SymbolDefinition
     ) -> SymbolDefinition:
         """
         Merge symbol properties, with child properties taking precedence.
@@ -315,7 +305,9 @@ class SymbolResolver:
 
         def check_symbol(current_lib_id: str) -> None:
             if current_lib_id in visited:
-                issues.append(f"Circular inheritance detected: {' -> '.join(chain + [current_lib_id])}")
+                issues.append(
+                    f"Circular inheritance detected: {' -> '.join(chain + [current_lib_id])}"
+                )
                 return
 
             visited.add(current_lib_id)
@@ -329,7 +321,9 @@ class SymbolResolver:
             if symbol.extends:
                 parent_lib_id = self._resolve_parent_lib_id(symbol.extends, symbol.library)
                 if not self._cache.has_symbol(parent_lib_id):
-                    issues.append(f"Parent symbol not found: {parent_lib_id} (extended by {current_lib_id})")
+                    issues.append(
+                        f"Parent symbol not found: {parent_lib_id} (extended by {current_lib_id})"
+                    )
                 else:
                     check_symbol(parent_lib_id)
 
@@ -364,4 +358,4 @@ class SymbolResolver:
 
             current_lib_id = self._resolve_parent_lib_id(symbol.extends, symbol.library)
 
-        return chain
+        return chain