kicad-sch-api 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

kicad_sch_api/library/cache.py

@@ -41,7 +41,7 @@ class SymbolDefinition:
 
     # Raw KiCAD data for exact format preservation
     raw_kicad_data: Any = None
-    
+
     # Symbol inheritance
     extends: Optional[str] = None  # Parent symbol name if this symbol extends another
 
@@ -263,7 +263,7 @@ class SymbolLibraryCache:
             Symbol definition if found, None otherwise
         """
         logger.debug(f"🔧 CACHE: Requesting symbol: {lib_id}")
-        
+
         # Check cache first
         if lib_id in self._symbols:
             self._cache_hits += 1
@@ -357,7 +357,7 @@ class SymbolLibraryCache:
     def _load_symbol(self, lib_id: str) -> Optional[SymbolDefinition]:
         """Load a single symbol from its library."""
         logger.debug(f"🔧 LOAD: Loading symbol {lib_id}")
-        
+
         if ":" not in lib_id:
             logger.warning(f"🔧 LOAD: Invalid lib_id format: {lib_id}")
             return None
@@ -423,29 +423,29 @@ class SymbolLibraryCache:
         try:
             # Extract symbol name from lib_id
             library_name, symbol_name = lib_id.split(":", 1)
-            
-            with open(library_path, 'r', encoding='utf-8') as f:
+
+            with open(library_path, "r", encoding="utf-8") as f:
                 content = f.read()
 
             # Parse the S-expression with symbol preservation
             parsed = sexpdata.loads(content, true=None, false=None, nil=None)
             logger.debug(f"🔧 PARSE: Parsed library file with {len(parsed)} top-level items")
-            
+
             # Find the symbol we're looking for
             symbol_data = self._find_symbol_in_parsed_data(parsed, symbol_name)
             if not symbol_data:
                 logger.debug(f"🔧 PARSE: Symbol {symbol_name} not found in {library_path}")
                 return None
-            
+
             logger.debug(f"🔧 PARSE: Found symbol {symbol_name} in library")
 
             # Extract the library name and symbol name for resolution
             library_name, symbol_name = lib_id.split(":", 1)
-            
+
             # Check if this symbol extends another symbol
             extends_symbol = self._check_extends_directive(symbol_data)
             logger.debug(f"🔧 CACHE: Symbol {lib_id} extends: {extends_symbol}")
-            
+
             # If this symbol extends another, we need to resolve it
             if extends_symbol:
                 resolved_symbol_data = self._resolve_extends_relationship(
@@ -455,7 +455,7 @@ class SymbolLibraryCache:
                     symbol_data = resolved_symbol_data
                     extends_symbol = None  # Clear extends after resolution
                     logger.debug(f"🔧 CACHE: Resolved extends for {lib_id}")
-            
+
             # Extract symbol information
             result = {
                 "raw_data": symbol_data,  # Store the raw parsed data
@@ -464,26 +464,26 @@ class SymbolLibraryCache:
                 "keywords": "",
                 "datasheet": "~",
                 "pins": [],
-                "extends": extends_symbol  # Should be None after resolution
+                "extends": extends_symbol,  # Should be None after resolution
             }
 
             # Extract properties from the symbol
             for item in symbol_data[1:]:
                 if isinstance(item, list) and len(item) > 0:
-                    if item[0] == sexpdata.Symbol('property'):
+                    if item[0] == sexpdata.Symbol("property"):
                         prop_name = item[1]
                         prop_value = item[2]
-                        
+
                         logger.debug(f"🔧 Processing property: {prop_name} = {prop_value}")
-                        if prop_name == sexpdata.Symbol('Reference'):
+                        if prop_name == sexpdata.Symbol("Reference"):
                             result["reference_prefix"] = str(prop_value)
                             logger.debug(f"🔧 Set reference_prefix: {str(prop_value)}")
-                        elif prop_name == sexpdata.Symbol('Description'):
+                        elif prop_name == sexpdata.Symbol("Description"):
                             result["Description"] = str(prop_value)  # Keep original case
                             logger.debug(f"🔧 Set Description: {str(prop_value)}")
-                        elif prop_name == sexpdata.Symbol('ki_keywords'):
+                        elif prop_name == sexpdata.Symbol("ki_keywords"):
                             result["keywords"] = str(prop_value)
-                        elif prop_name == sexpdata.Symbol('Datasheet'):
+                        elif prop_name == sexpdata.Symbol("Datasheet"):
                             result["Datasheet"] = str(prop_value)  # Keep original case
                             logger.debug(f"🔧 Set Datasheet: {str(prop_value)}")
 
@@ -500,7 +500,7 @@ class SymbolLibraryCache:
     def _find_symbol_in_parsed_data(self, parsed_data: List, symbol_name: str) -> Optional[List]:
         """Find a specific symbol in parsed KiCAD library data."""
         logger.debug(f"🔧 FIND: Looking for symbol '{symbol_name}' in parsed data")
-        
+
         if not isinstance(parsed_data, list):
             logger.debug(f"🔧 FIND: Parsed data is not a list: {type(parsed_data)}")
             return None
@@ -509,61 +509,66 @@ class SymbolLibraryCache:
         available_symbols = []
         for item in parsed_data:
             if isinstance(item, list) and len(item) >= 2:
-                if item[0] == sexpdata.Symbol('symbol'):
+                if item[0] == sexpdata.Symbol("symbol"):
                     available_symbols.append(str(item[1]).strip('"'))
-        
-        logger.debug(f"🔧 FIND: Available symbols in library: {available_symbols[:10]}...")  # Show first 10
+
+        logger.debug(
+            f"🔧 FIND: Available symbols in library: {available_symbols[:10]}..."
+        )  # Show first 10
 
         # Search through the parsed data for the symbol
         for item in parsed_data:
             if isinstance(item, list) and len(item) >= 2:
-                if (item[0] == sexpdata.Symbol('symbol') and 
-                    len(item) > 1 and 
-                    str(item[1]).strip('"') == symbol_name):
+                if (
+                    item[0] == sexpdata.Symbol("symbol")
+                    and len(item) > 1
+                    and str(item[1]).strip('"') == symbol_name
+                ):
                     logger.debug(f"🔧 FIND: Found symbol '{symbol_name}'")
                     return item
-        
-        logger.debug(f"🔧 FIND: Symbol '{symbol_name}' not found in library")                
+
+        logger.debug(f"🔧 FIND: Symbol '{symbol_name}' not found in library")
         return None
 
     def _check_extends_directive(self, symbol_data: List) -> Optional[str]:
         """Check if symbol has extends directive and return parent symbol name."""
         if not isinstance(symbol_data, list):
             return None
-            
+
         for item in symbol_data[1:]:
             if isinstance(item, list) and len(item) >= 2:
-                if item[0] == sexpdata.Symbol('extends'):
+                if item[0] == sexpdata.Symbol("extends"):
                     parent_name = str(item[1]).strip('"')
                     logger.debug(f"Found extends directive: {parent_name}")
                     return parent_name
         return None
 
-    def _resolve_extends_relationship(self, child_symbol_data: List, parent_name: str, 
-                                    library_path: Path, library_name: str) -> Optional[List]:
+    def _resolve_extends_relationship(
+        self, child_symbol_data: List, parent_name: str, library_path: Path, library_name: str
+    ) -> Optional[List]:
         """Resolve extends relationship by merging parent symbol into child."""
         logger.debug(f"🔧 RESOLVE: Resolving extends {parent_name} for child symbol")
-        
+
         try:
             # Load the parent symbol from the same library
-            with open(library_path, 'r', encoding='utf-8') as f:
+            with open(library_path, "r", encoding="utf-8") as f:
                 content = f.read()
-            
+
             parsed = sexpdata.loads(content, true=None, false=None, nil=None)
             parent_symbol_data = self._find_symbol_in_parsed_data(parsed, parent_name)
-            
+
             if not parent_symbol_data:
                 logger.warning(f"🔧 RESOLVE: Parent symbol {parent_name} not found in library")
                 return None
-            
+
             logger.debug(f"🔧 RESOLVE: Found parent symbol {parent_name}")
-            
+
             # Merge parent into child (adapt from circuit-synth logic)
             merged_symbol = self._merge_parent_into_child(child_symbol_data, parent_symbol_data)
             logger.debug(f"🔧 RESOLVE: Merged parent into child symbol")
-            
+
             return merged_symbol
-            
+
         except Exception as e:
             logger.error(f"🔧 RESOLVE: Error resolving extends: {e}")
             return None
@@ -571,27 +576,30 @@ class SymbolLibraryCache:
     def _merge_parent_into_child(self, child_data: List, parent_data: List) -> List:
         """Merge parent symbol graphics and pins into child symbol."""
         import copy
-        
+
         # Get child and parent symbol names for unit renaming
         child_name = str(child_data[1]).strip('"') if len(child_data) > 1 else "Child"
         parent_name = str(parent_data[1]).strip('"') if len(parent_data) > 1 else "Parent"
-        
+
         logger.debug(f"🔧 MERGE: Merging {parent_name} into {child_name}")
-        
+
         # Start with child symbol structure
         merged = copy.deepcopy(child_data)
-        
+
         # Remove the extends directive from child
-        merged = [item for item in merged if not (
-            isinstance(item, list) and len(item) >= 2 and 
-            item[0] == sexpdata.Symbol('extends')
-        )]
-        
+        merged = [
+            item
+            for item in merged
+            if not (
+                isinstance(item, list) and len(item) >= 2 and item[0] == sexpdata.Symbol("extends")
+            )
+        ]
+
         # Copy all graphics and unit definitions from parent
         for item in parent_data[1:]:
             if isinstance(item, list) and len(item) > 0:
                 # Copy symbol unit definitions (contain graphics and pins)
-                if item[0] == sexpdata.Symbol('symbol'):
+                if item[0] == sexpdata.Symbol("symbol"):
                     # Rename unit from parent name to child name
                     unit_item = copy.deepcopy(item)
                     if len(unit_item) > 1:
@@ -602,36 +610,36 @@ class SymbolLibraryCache:
                         logger.debug(f"🔧 MERGE: Renamed unit {old_unit_name} -> {new_unit_name}")
                     merged.append(unit_item)
                 # Copy other non-property elements (child properties override parent)
-                elif item[0] not in [sexpdata.Symbol('property')]:
+                elif item[0] not in [sexpdata.Symbol("property")]:
                     merged.append(copy.deepcopy(item))
-        
+
         logger.debug(f"🔧 MERGE: Merged symbol has {len(merged)} elements")
         return merged
 
     def _extract_pins_from_symbol(self, symbol_data: List) -> List[SchematicPin]:
         """Extract pins from symbol data."""
         pins = []
-        
+
         # Look for symbol sub-definitions like "R_1_1" that contain pins
         for item in symbol_data[1:]:
             if isinstance(item, list) and len(item) > 0:
-                if item[0] == sexpdata.Symbol('symbol'):
+                if item[0] == sexpdata.Symbol("symbol"):
                     # This is a symbol unit definition, look for pins
                     pins.extend(self._extract_pins_from_unit(item))
-                    
+
         return pins
 
     def _extract_pins_from_unit(self, unit_data: List) -> List[SchematicPin]:
         """Extract pins from a symbol unit definition."""
         pins = []
-        
+
         for item in unit_data[1:]:
             if isinstance(item, list) and len(item) > 0:
-                if item[0] == sexpdata.Symbol('pin'):
+                if item[0] == sexpdata.Symbol("pin"):
                     pin = self._parse_pin_definition(item)
                     if pin:
                         pins.append(pin)
-                        
+
         return pins
 
     def _parse_pin_definition(self, pin_data: List) -> Optional[SchematicPin]:
@@ -640,27 +648,27 @@ class SymbolLibraryCache:
             # pin_data format: (pin passive line (at 0 3.81 270) (length 1.27) ...)
             pin_type_str = str(pin_data[1]) if len(pin_data) > 1 else "passive"
             pin_shape_str = str(pin_data[2]) if len(pin_data) > 2 else "line"
-            
+
             position = Point(0, 0)
             length = 2.54
             rotation = 0
             name = "~"
             number = "1"
-            
+
             # Parse pin attributes
             for item in pin_data[3:]:
                 if isinstance(item, list) and len(item) > 0:
-                    if item[0] == sexpdata.Symbol('at'):
+                    if item[0] == sexpdata.Symbol("at"):
                         # (at x y rotation)
                         if len(item) >= 3:
                             position = Point(float(item[1]), float(item[2]))
                             if len(item) >= 4:
                                 rotation = float(item[3])
-                    elif item[0] == sexpdata.Symbol('length'):
+                    elif item[0] == sexpdata.Symbol("length"):
                         length = float(item[1])
-                    elif item[0] == sexpdata.Symbol('name'):
+                    elif item[0] == sexpdata.Symbol("name"):
                         name = str(item[1]).strip('"')
-                    elif item[0] == sexpdata.Symbol('number'):
+                    elif item[0] == sexpdata.Symbol("number"):
                         number = str(item[1]).strip('"')
 
             # Map pin type

{kicad_sch_api-0.2.0.dist-info → kicad_sch_api-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.2.0
+Version: 0.2.1
 Summary: Professional KiCAD schematic manipulation library with exact format preservation
 Author-email: Circuit-Synth <shane@circuit-synth.com>
 Maintainer-email: Circuit-Synth <shane@circuit-synth.com>
@@ -56,6 +56,9 @@ Create and manipulate KiCAD schematic files programmatically with guaranteed exa
 - **🏗️ Professional Component Management**: Object-oriented collections with search and validation
 - **⚡ High Performance**: Optimized for large schematics with intelligent caching
 - **🔍 Real KiCAD Library Integration**: Access to actual KiCAD symbol libraries and validation
+- **📐 Component Bounding Boxes**: Precise component boundary calculation and visualization
+- **🎨 Colored Rectangle Graphics**: KiCAD-compatible rectangles with all stroke types and colors
+- **🛣️ Manhattan Routing**: Intelligent wire routing with obstacle avoidance
 - **🤖 AI Agent Ready**: MCP server for seamless integration with AI development tools
 - **📚 Hierarchical Design**: Complete support for multi-sheet schematic projects
 
@@ -100,6 +103,16 @@ capacitor = sch.components.add(
     footprint="Capacitor_SMD:C_0603_1608Metric"
 )
 
+# Add wires for connectivity
+sch.wires.add(start=(100, 110), end=(150, 110))
+
+# Pin-to-pin wiring (NEW in v0.3.1)
+wire_uuid = sch.add_wire_between_pins("R1", "2", "C1", "1")  # Connect R1 pin 2 to C1 pin 1
+external_wire = sch.add_wire_to_pin((50, 100), "R1", "1")   # Connect external point to R1 pin 1
+
+# Add labels for nets
+sch.add_label("VCC", position=(125, 110))
+
 # Save with exact format preservation
 sch.save("my_circuit.kicad_sch")
 ```
@@ -134,6 +147,131 @@ power_sch.save("power.kicad_sch")
 
 ## 🔧 Advanced Features
 
+### Component Bounding Boxes and Colored Graphics (NEW in v0.3.1)
+
+```python
+from kicad_sch_api.core.component_bounds import get_component_bounding_box
+
+# Add components
+resistor = sch.components.add("Device:R", "R1", "10k", (100, 100))
+opamp = sch.components.add("Amplifier_Operational:LM358", "U1", "LM358", (150, 100))
+
+# Get component bounding boxes
+bbox_body = get_component_bounding_box(resistor, include_properties=False)
+bbox_full = get_component_bounding_box(resistor, include_properties=True)
+
+# Draw colored bounding box rectangles
+sch.draw_bounding_box(bbox_body, stroke_width=0.5, stroke_color="blue", stroke_type="solid")
+sch.draw_bounding_box(bbox_full, stroke_width=0.3, stroke_color="red", stroke_type="dash")
+
+# Draw bounding boxes for all components at once
+bbox_uuids = sch.draw_component_bounding_boxes(
+    include_properties=True,
+    stroke_width=0.4,
+    stroke_color="green", 
+    stroke_type="dot"
+)
+```
+
+### Manhattan Routing with Obstacle Avoidance (NEW in v0.3.1)
+
+```python
+from kicad_sch_api.core.manhattan_routing import ManhattanRouter
+from kicad_sch_api.core.types import Point
+
+# Create router
+router = ManhattanRouter()
+
+# Add components that act as obstacles
+r1 = sch.components.add("Device:R", "R1", "1k", (50, 50))
+r2 = sch.components.add("Device:R", "R2", "2k", (150, 150))
+obstacle = sch.components.add("Device:C", "C1", "100nF", (100, 100))
+
+# Get obstacle bounding boxes
+obstacle_bbox = get_component_bounding_box(obstacle, include_properties=False)
+
+# Route around obstacles
+start_point = Point(r1.position.x, r1.position.y)
+end_point = Point(r2.position.x, r2.position.y)
+path = router.route_between_points(start_point, end_point, [obstacle_bbox], clearance=2.0)
+
+# Add wires along the path
+for i in range(len(path) - 1):
+    sch.wires.add(path[i], path[i + 1])
+```
+
+### Pin-to-Pin Wiring
+
+```python
+# Connect component pins directly - automatically calculates pin positions
+wire_uuid = sch.add_wire_between_pins("R1", "2", "R2", "1")  # R1 pin 2 to R2 pin 1
+
+# Connect arbitrary point to component pin
+external_wire = sch.add_wire_to_pin((75, 125), "R1", "1")    # External point to R1 pin 1
+tuple_wire = sch.add_wire_to_pin(Point(100, 150), "C1", "2") # Using Point object
+
+# Get component pin positions for advanced operations
+pin_position = sch.get_component_pin_position("R1", "1")
+if pin_position:
+    print(f"R1 pin 1 is at ({pin_position.x:.2f}, {pin_position.y:.2f})")
+
+# Error handling - returns None for invalid components/pins
+invalid_wire = sch.add_wire_between_pins("R999", "1", "R1", "1")  # Returns None
+```
+
+### Component Bounding Box Visualization (NEW in v0.3.1)
+
+```python
+from kicad_sch_api.core.component_bounds import get_component_bounding_box
+
+# Get component bounding box (body only)
+resistor = sch.components.get("R1")
+bbox = get_component_bounding_box(resistor, include_properties=False)
+print(f"R1 body size: {bbox.width:.2f}×{bbox.height:.2f}mm")
+
+# Get bounding box including properties (reference, value, etc.)
+bbox_with_props = get_component_bounding_box(resistor, include_properties=True)
+print(f"R1 with labels: {bbox_with_props.width:.2f}×{bbox_with_props.height:.2f}mm")
+
+# Draw bounding box as rectangle graphics (for visualization/debugging)
+rect_uuid = sch.draw_bounding_box(bbox)
+print(f"Drew bounding box rectangle: {rect_uuid}")
+
+# Draw bounding boxes for all components
+bbox_uuids = sch.draw_component_bounding_boxes(
+    include_properties=False  # True to include reference/value labels
+)
+print(f"Drew {len(bbox_uuids)} component bounding boxes")
+
+# Expand bounding box for clearance analysis
+expanded_bbox = bbox.expand(2.54)  # Expand by 2.54mm (0.1 inch) 
+clearance_rect = sch.draw_bounding_box(expanded_bbox)
+```
+
+### Manhattan Routing with Obstacle Avoidance (NEW in v0.3.1)
+
+```python
+# Automatic Manhattan routing between component pins
+wire_segments = sch.auto_route_pins(
+    "R1", "2",           # From component R1, pin 2
+    "R2", "1",           # To component R2, pin 1  
+    routing_mode="manhattan",  # Manhattan (L-shaped) routing
+    avoid_components=True      # Avoid component bounding boxes
+)
+
+# Direct routing (straight line)
+direct_wire = sch.auto_route_pins("C1", "1", "C2", "2", routing_mode="direct")
+
+# Manual obstacle avoidance using bounding boxes
+bbox_r1 = get_component_bounding_box(sch.components.get("R1"))
+bbox_r2 = get_component_bounding_box(sch.components.get("R2"))
+
+# Check if routing path intersects with component
+def path_clear(start, end, obstacles):
+    # Custom collision detection logic
+    return not any(bbox.intersects_line(start, end) for bbox in obstacles)
+```
+
 ### Component Search and Management
 
 ```python
@@ -154,6 +292,53 @@ validation_result = sch.components.validate_component(
 )
 ```
 
+### Component and Element Removal
+
+```python
+# Remove components by reference
+removed = sch.components.remove("R1")  # Returns True if removed
+
+# Remove wires, labels, and other elements
+sch.remove_wire(wire_uuid)
+sch.remove_label(label_uuid)
+sch.remove_hierarchical_label(label_uuid)
+
+# Remove from collections
+sch.wires.remove(wire_uuid)
+sch.junctions.remove(junction_uuid)
+
+# lib_symbols are automatically cleaned up when last component of type is removed
+```
+
+### Configuration and Customization
+
+```python
+import kicad_sch_api as ksa
+
+# Access global configuration
+config = ksa.config
+
+# Customize property positioning
+config.properties.reference_y = -2.0  # Move reference labels higher
+config.properties.value_y = 2.0       # Move value labels lower
+
+# Customize tolerances and precision
+config.tolerance.position_tolerance = 0.05  # Tighter position matching
+config.tolerance.wire_segment_min = 0.005   # Different wire segment threshold
+
+# Customize defaults
+config.defaults.project_name = "my_company_project"
+config.defaults.stroke_width = 0.1
+
+# Grid and spacing customization
+config.grid.unit_spacing = 10.0       # Tighter multi-unit IC spacing
+config.grid.component_spacing = 5.0   # Closer component placement
+
+# Sheet settings for hierarchical designs
+config.sheet.name_offset_y = -1.0     # Different sheet label position
+config.sheet.file_offset_y = 1.0      # Different file label position
+```
+
 ### KiCAD Integration
 
 ```python
@@ -170,48 +355,23 @@ net_info = netlist.analyze_net("VCC")
 
 ## 🤖 AI Agent Integration
 
-This library serves as the foundational layer for AI agent integration through dedicated MCP (Model Context Protocol) servers.
-
-### MCP Server Integration
-
-```bash
-# Install the dedicated MCP server (separate package)
-pip install mcp-kicad-sch-api
-
-# Configure for Claude Code
-code mcp install mcp-kicad-sch-api
-```
-
-### Library Design for MCP Compatibility
-
-This library is specifically designed to provide:
-- **Stable API**: Consistent interface for MCP servers to build upon
-- **Format Preservation**: Guaranteed exact KiCAD output for reliable automation
-- **Professional Validation**: Component and library validation for quality assurance
-- **Performance**: Optimized for AI agent workloads with caching and bulk operations
-
-### Usage with AI Agents
-
-```
-# Natural language commands to your AI agent:
-"Create a voltage divider with two 10kΩ resistors"
-"Add an ESP32 microcontroller with USB connector" 
-"Generate a hierarchical schematic with power supply subcircuit"
-```
-
-**Related MCP Servers:**
-- **[mcp-kicad-sch-api](https://github.com/circuit-synth/mcp-kicad-sch-api)**: Full-featured MCP server built on this library
+This library serves as the foundation for AI agent integration. For Claude Code or other AI agents, use the **[mcp-kicad-sch-api](https://github.com/circuit-synth/mcp-kicad-sch-api)** MCP server (included as a submodule in `submodules/mcp-kicad-sch-api/`).
 
 ## 🏗️ Architecture
 
 ### Library Structure
 
 ```
-kicad_sch_api/
-├── core/              # Core schematic manipulation
-├── library/           # KiCAD library integration
-├── integration/       # KiCAD CLI and tool integration
-└── utils/            # Validation and utilities
+kicad-sch-api/
+├── kicad_sch_api/           # Core Python library
+│   ├── core/                # Core schematic manipulation
+│   ├── library/             # KiCAD library integration
+│   ├── discovery/           # Component search and indexing
+│   └── utils/              # Validation and utilities
+├── submodules/              # Related projects as submodules
+│   └── mcp-kicad-sch-api/  # MCP server for AI agents
+├── tests/                   # Comprehensive test suite
+└── examples/               # Usage examples and tutorials
 ```
 
 ### Design Principles
@@ -225,18 +385,30 @@ kicad_sch_api/
 ## 🧪 Testing & Quality
 
 ```bash
-# Run all tests
+# Run all tests (29 tests covering all functionality)
 uv run pytest tests/ -v
 
-# Format preservation tests (critical)
+# Format preservation tests (critical - exact KiCAD output matching)
 uv run pytest tests/reference_tests/ -v
 
+# Component removal tests (comprehensive removal functionality)
+uv run pytest tests/test_*_removal.py -v
+
 # Code quality checks
 uv run black kicad_sch_api/ tests/
 uv run mypy kicad_sch_api/
 uv run flake8 kicad_sch_api/ tests/
 ```
 
+### Test Categories
+
+- **Format Preservation**: Byte-for-byte compatibility with KiCAD native files
+- **Component Management**: Creation, modification, and removal of components
+- **Element Operations**: Wires, labels, junctions, hierarchical sheets
+- **Configuration**: Customizable settings and behavior
+- **Performance**: Large schematic handling and optimization
+- **Integration**: Real KiCAD library compatibility
+
 ## 🆚 Why This Library?
 
 ### vs. Direct KiCAD File Editing
@@ -301,7 +473,7 @@ MIT License - see [LICENSE](LICENSE) for details.
 
 ## 🔗 Related Projects
 
-- **[mcp-kicad-sch-api](https://github.com/circuit-synth/mcp-kicad-sch-api)**: MCP server for AI agents built on this library
+- **[mcp-kicad-sch-api](https://github.com/circuit-synth/mcp-kicad-sch-api)**: MCP server for AI agents built on this library (included as submodule)
 - **[circuit-synth](https://github.com/circuit-synth/circuit-synth)**: High-level circuit design automation using this library
 - **[Claude Code](https://claude.ai/code)**: AI development environment with MCP support
 - **[KiCAD](https://kicad.org/)**: Open source electronics design automation suite

kicad_sch_api-0.2.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+kicad_sch_api/__init__.py,sha256=pxSnH_vkk5oJSRMp55RsitpoxRjum84Jw5JpQrGcSPc,2919
+kicad_sch_api/cli.py,sha256=ZzmwzfHEvPgGfCiQBU4G2LBAyRtMNiBRoY21pivJSYc,7621
+kicad_sch_api/py.typed,sha256=e4ldqxwpY7pNDG1olbvj4HSKr8sZ9vxgA_2ek8xXn-Q,70
+kicad_sch_api/core/__init__.py,sha256=ur_KeYBlGKl-e1hLpLdxAhGV2A-PCCGkcqd0r6KSeBA,566
+kicad_sch_api/core/component_bounds.py,sha256=BFYJYULyzs5it2hN7bHTimyS9Vet4dxsMklRStob-F4,17509
+kicad_sch_api/core/components.py,sha256=tXRL18GObl2u94wl5jP-1ID56s_UD9F1gQ_iRIyZ_Kw,25290
+kicad_sch_api/core/config.py,sha256=itw0j3DeIEHaFVf8p3mfAS1SP6jclBwvMv7NPdkThE4,4309
+kicad_sch_api/core/formatter.py,sha256=ggOc1PZZAGkpdMMNxm1ukCCz9riYnd_sM93nB0fBYuw,20390
+kicad_sch_api/core/geometry.py,sha256=27SgN0padLbQuTi8MV6UUCp6Pyaiv8V9gmYDOhfwny8,2947
+kicad_sch_api/core/ic_manager.py,sha256=Kg0HIOMU-TGXiIkrnwcHFQ1Kfv_3rW2U1cwBKJsKopc,7219
+kicad_sch_api/core/junctions.py,sha256=Ay6BsWX_DLs-wB0eMA2CytKKq0N8Ja41ZubJWpAqNgM,6122
+kicad_sch_api/core/manhattan_routing.py,sha256=t_T2u0zsQB-a8dTijFmY-qFq-oDt2qDebYyXzD_pBWI,15989
+kicad_sch_api/core/parser.py,sha256=raQdKrJZgw3v2ZKyECK7SbzqLMD762H-lQWwxUMDwks,52992
+kicad_sch_api/core/pin_utils.py,sha256=XGEow3HzBTyT8a0B_ZC8foMvwzYaENSaqTUwDW1rz24,5417
+kicad_sch_api/core/schematic.py,sha256=5BSPVWHgj9uwzlwCBT6JSg7sjx9jlADd1aEprO_yOd0,59498
+kicad_sch_api/core/simple_manhattan.py,sha256=CvIHvwmfABPF-COzhblYxEgRoR_R_eD-lmBFHHjDuMI,7241
+kicad_sch_api/core/types.py,sha256=exIJ0cA1puYj09uxiq6inom2YVAs6JTDjf1ka0bKN8g,12872
+kicad_sch_api/core/wire_routing.py,sha256=G-C7S-ntQxwuu1z3OaaYlkURXwKE4r4xmhbbi6cvvaI,12830
+kicad_sch_api/core/wires.py,sha256=608t9oH4UzppdGgNgUd-ABK6T-ahyETZwhO_-CuKFO8,8319
+kicad_sch_api/discovery/__init__.py,sha256=qSuCsnC-hVtaLYE8fwd-Gea6JKwEVGPQ-hSNDNJYsIU,329
+kicad_sch_api/discovery/search_index.py,sha256=KgQT8ipT9OU6ktUwhDZ37Mao0Cba0fJOsxUk9m8ZKbY,15856
+kicad_sch_api/library/__init__.py,sha256=NG9UTdcpn25Bl9tPsYs9ED7bvpaVPVdtLMbnxkQkOnU,250
+kicad_sch_api/library/cache.py,sha256=7na88grl465WHwUOGuOzYrrWwjsMBXhXVtxhnaJ9GBY,33208
+kicad_sch_api/utils/__init__.py,sha256=1V_yGgI7jro6MUc4Pviux_WIeJ1wmiYFID186SZwWLQ,277
+kicad_sch_api/utils/validation.py,sha256=XlWGRZJb3cOPYpU9sLQQgC_NASwbi6W-LCN7PzUmaPY,15626
+kicad_sch_api-0.2.1.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
+kicad_sch_api-0.2.1.dist-info/METADATA,sha256=UJaikwtrjEvTIYzOZpeYA1-nP6LlQpBQf_Fc9wzHO2M,17183
+kicad_sch_api-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kicad_sch_api-0.2.1.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
+kicad_sch_api-0.2.1.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
+kicad_sch_api-0.2.1.dist-info/RECORD,,