kicad-sch-api 0.0.2__py3-none-any.whl → 0.1.0__py3-none-any.whl

kicad_sch_api/library/cache.py

@@ -14,6 +14,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
+import sexpdata
+
 from ..core.types import PinShape, PinType, Point, SchematicPin
 from ..utils.validation import ValidationError
 
@@ -37,6 +39,12 @@ class SymbolDefinition:
     power_symbol: bool = False
     graphic_elements: List[Dict[str, Any]] = field(default_factory=list)
 
+    # 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
+
     # Performance metrics
     load_time: float = 0.0
     access_count: int = 0
@@ -254,15 +262,19 @@ class SymbolLibraryCache:
         Returns:
             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
             symbol = self._symbols[lib_id]
             symbol.access_count += 1
             symbol.last_accessed = time.time()
+            logger.debug(f"🔧 CACHE: Cache hit for {lib_id}")
             return symbol
 
         # Cache miss - try to load symbol
+        logger.debug(f"🔧 CACHE: Cache miss for {lib_id}, loading...")
         self._cache_misses += 1
         return self._load_symbol(lib_id)
 
@@ -344,17 +356,22 @@ 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"Invalid lib_id format: {lib_id}")
+            logger.warning(f"🔧 LOAD: Invalid lib_id format: {lib_id}")
             return None
 
         library_name, symbol_name = lib_id.split(":", 1)
+        logger.debug(f"🔧 LOAD: Library: {library_name}, Symbol: {symbol_name}")
 
         if library_name not in self._library_index:
-            logger.warning(f"Library not found: {library_name}")
+            logger.warning(f"🔧 LOAD: Library not found: {library_name}")
+            logger.debug(f"🔧 LOAD: Available libraries: {list(self._library_index.keys())}")
             return None
 
         library_path = self._library_index[library_name]
+        logger.debug(f"🔧 LOAD: Library path: {library_path}")
         return self._load_symbol_from_library(library_path, lib_id)
 
     def _load_symbol_from_library(
@@ -364,22 +381,32 @@ class SymbolLibraryCache:
         start_time = time.time()
 
         try:
-            # This is a simplified version - in reality, you'd parse the .kicad_sym file
-            # For now, create a basic symbol definition
             library_name, symbol_name = lib_id.split(":", 1)
 
-            # Create basic symbol definition
-            # In a real implementation, this would parse the actual .kicad_sym file
+            # Parse the .kicad_sym file to find the symbol
+            symbol_data = self._parse_kicad_symbol_file(library_path, lib_id)
+            if not symbol_data:
+                logger.warning(f"Symbol {symbol_name} not found in {library_path}")
+                return None
+
+            # Create SymbolDefinition from parsed data
             symbol = SymbolDefinition(
                 lib_id=lib_id,
                 name=symbol_name,
                 library=library_name,
-                reference_prefix=self._guess_reference_prefix(symbol_name),
-                description=f"{symbol_name} component",
-                pins=[],  # Would be loaded from actual file
+                reference_prefix=symbol_data.get("reference_prefix", "U"),
+                description=symbol_data.get("description", ""),
+                keywords=symbol_data.get("keywords", ""),
+                datasheet=symbol_data.get("datasheet", "~"),
+                pins=symbol_data.get("pins", []),
+                extends=symbol_data.get("extends"),  # Store extends information
                 load_time=time.time() - start_time,
             )
 
+            # Store the raw symbol data for later use in schematic generation
+            symbol.raw_kicad_data = symbol_data.get("raw_data", {})
+            logger.debug(f"🔧 CREATED: SymbolDefinition for {lib_id}, extends: {symbol.extends}")
+
             self._symbols[lib_id] = symbol
             self._symbol_index[symbol_name] = lib_id
             self._total_load_time += symbol.load_time
@@ -391,6 +418,285 @@ class SymbolLibraryCache:
             logger.error(f"Error loading symbol {lib_id} from {library_path}: {e}")
             return None
 
+    def _parse_kicad_symbol_file(self, library_path: Path, lib_id: str) -> Optional[Dict[str, Any]]:
+        """Parse a KiCAD .kicad_sym file to extract a specific symbol."""
+        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:
+                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(
+                    symbol_data, extends_symbol, library_path, library_name
+                )
+                if resolved_symbol_data:
+                    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
+                "reference_prefix": "U",  # Default
+                "description": "",
+                "keywords": "",
+                "datasheet": "~",
+                "pins": [],
+                "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'):
+                        prop_name = item[1]
+                        prop_value = item[2]
+                        
+                        logger.debug(f"🔧 Processing property: {prop_name} = {prop_value}")
+                        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'):
+                            result["Description"] = str(prop_value)  # Keep original case
+                            logger.debug(f"🔧 Set Description: {str(prop_value)}")
+                        elif prop_name == sexpdata.Symbol('ki_keywords'):
+                            result["keywords"] = str(prop_value)
+                        elif prop_name == sexpdata.Symbol('Datasheet'):
+                            result["Datasheet"] = str(prop_value)  # Keep original case
+                            logger.debug(f"🔧 Set Datasheet: {str(prop_value)}")
+
+            # Extract pins (this is simplified - pins are in symbol sub-definitions)
+            # For now, we'll extract pins from the actual symbol structure
+            result["pins"] = self._extract_pins_from_symbol(symbol_data)
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error parsing {library_path}: {e}")
+            return None
+
+    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
+
+        # First, log all available symbols for debugging
+        available_symbols = []
+        for item in parsed_data:
+            if isinstance(item, list) and len(item) >= 2:
+                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
+
+        # 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):
+                    logger.debug(f"🔧 FIND: Found symbol '{symbol_name}'")
+                    return item
+        
+        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'):
+                    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]:
+        """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:
+                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
+
+    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')
+        )]
+        
+        # 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'):
+                    # Rename unit from parent name to child name
+                    unit_item = copy.deepcopy(item)
+                    if len(unit_item) > 1:
+                        old_unit_name = str(unit_item[1]).strip('"')
+                        # Replace parent name with child name in unit name
+                        new_unit_name = old_unit_name.replace(parent_name, child_name)
+                        unit_item[1] = new_unit_name
+                        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')]:
+                    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'):
+                    # 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'):
+                    pin = self._parse_pin_definition(item)
+                    if pin:
+                        pins.append(pin)
+                        
+        return pins
+
+    def _parse_pin_definition(self, pin_data: List) -> Optional[SchematicPin]:
+        """Parse a pin definition from KiCAD format."""
+        try:
+            # 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'):
+                        # (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'):
+                        length = float(item[1])
+                    elif item[0] == sexpdata.Symbol('name'):
+                        name = str(item[1]).strip('"')
+                    elif item[0] == sexpdata.Symbol('number'):
+                        number = str(item[1]).strip('"')
+
+            # Map pin type
+            pin_type = PinType.PASSIVE
+            if pin_type_str == "input":
+                pin_type = PinType.INPUT
+            elif pin_type_str == "output":
+                pin_type = PinType.OUTPUT
+            elif pin_type_str == "bidirectional":
+                pin_type = PinType.BIDIRECTIONAL
+            elif pin_type_str == "power_in":
+                pin_type = PinType.POWER_IN
+            elif pin_type_str == "power_out":
+                pin_type = PinType.POWER_OUT
+
+            # Map pin shape
+            pin_shape = PinShape.LINE
+            if pin_shape_str == "inverted":
+                pin_shape = PinShape.INVERTED
+            elif pin_shape_str == "clock":
+                pin_shape = PinShape.CLOCK
+
+            return SchematicPin(
+                number=number,
+                name=name,
+                position=position,
+                pin_type=pin_type,
+                pin_shape=pin_shape,
+                length=length,
+                rotation=rotation,
+            )
+
+        except Exception as e:
+            logger.error(f"Error parsing pin definition: {e}")
+            return None
+
     def _load_library(self, library_path: Path) -> bool:
         """Load all symbols from a library file."""
         library_name = library_path.stem
@@ -471,6 +777,8 @@ class SymbolLibraryCache:
                     Path("/usr/share/kicad/symbols"),
                     Path("/usr/local/share/kicad/symbols"),
                     Path.home() / ".local/share/kicad/symbols",
+                    # macOS KiCAD.app bundle path
+                    Path("/Applications/KiCad/KiCad.app/Contents/SharedSupport/symbols"),
                 ]
             )
 
@@ -482,7 +790,10 @@ class SymbolLibraryCache:
             ]
         )
 
-        return [path for path in search_paths if path.exists()]
+        logger.debug(f"Potential library search paths: {search_paths}")
+        existing_paths = [path for path in search_paths if path.exists()]
+        logger.debug(f"Existing library search paths: {existing_paths}")
+        return existing_paths
 
     def _load_persistent_index(self):
         """Load persistent symbol index from disk."""

kicad_sch_api/utils/validation.py

@@ -87,7 +87,7 @@ class SchematicValidator:
         """
         self.strict = strict
         self.issues = []
-        self._valid_reference_pattern = re.compile(r"^(#[A-Z]+[0-9]+|[A-Z]+[0-9]*)$")
+        self._valid_reference_pattern = re.compile(r"^(#[A-Z]+[0-9]+|[A-Z]+[0-9]*[A-Z]?)$")
         self._valid_lib_id_pattern = re.compile(r"^[^:]+:[^:]+$")
 
     def validate_schematic_data(self, schematic_data: Dict[str, Any]) -> List[ValidationIssue]:

{kicad_sch_api-0.0.2.dist-info → kicad_sch_api-0.1.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.0.2
+Version: 0.1.0
 Summary: Professional KiCAD schematic manipulation library with exact format preservation and AI agent integration
 Author-email: Circuit-Synth <info@circuit-synth.com>
 Maintainer-email: Circuit-Synth <info@circuit-synth.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/circuit-synth/kicad-sch-api
 Project-URL: Documentation, https://circuit-synth.github.io/kicad-sch-api/
 Project-URL: Repository, https://github.com/circuit-synth/kicad-sch-api.git
@@ -15,7 +15,6 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -59,13 +58,13 @@ Dynamic: license-file
 
 ## 🆚 vs. Existing Solutions
 
-| Feature | kicad-sch-api | kicad-skip | KiCAD Official API |
-|---------|---------------|------------|-------------------|
-| **Schematic Support** | ✅ Full | ✅ Full | ❌ PCB Only |
+| Feature | kicad-sch-api | Other Solutions | KiCAD Official API |
+|---------|---------------|-----------------|-------------------|
+| **Schematic Support** | ✅ Full | ⚠️ Varies | ❌ PCB Only |
 | **Format Preservation** | ✅ Exact | ❌ Basic | N/A |
 | **Performance** | ✅ Optimized | ⚠️ Basic | N/A |
-| **Library Management** | ✅ Advanced | ⚠️ Basic | N/A |
-| **Runtime Dependencies** | ❌ None | ❌ None | ✅ KiCAD Required |
+| **Library Management** | ✅ Advanced | ⚠️ Limited | N/A |
+| **Runtime Dependencies** | ❌ None | ⚠️ Varies | ✅ KiCAD Required |
 
 ## 📦 Installation
 
@@ -89,22 +88,19 @@ npm run build
 ```python
 import kicad_sch_api as ksa
 
-# Load existing schematic
-sch = ksa.load_schematic('my_circuit.kicad_sch')
+# Create new schematic
+sch = ksa.create_schematic('My Circuit')
 
 # Add components
-resistor = sch.components.add('Device:R', ref='R1', value='10k', pos=(100, 100))
-capacitor = sch.components.add('Device:C', ref='C1', value='0.1uF', pos=(150, 100))
+resistor = sch.components.add('Device:R', reference='R1', value='10k', position=(100, 100))
+capacitor = sch.components.add('Device:C', reference='C1', value='0.1uF', position=(150, 100))
 
 # Update properties
 resistor.footprint = 'Resistor_SMD:R_0603_1608Metric'
 resistor.set_property('MPN', 'RC0603FR-0710KL')
 
-# Connect components
-sch.add_wire(resistor.get_pin_position('2'), capacitor.get_pin_position('1'))
-
 # Save with exact format preservation
-sch.save()  # Preserves original formatting exactly
+sch.save('my_circuit.kicad_sch')
 ```
 
 ### Advanced Operations
@@ -204,7 +200,7 @@ MIT License - see [LICENSE](LICENSE) for details.
 ## 🔗 Related Projects
 
 - **[circuit-synth](https://github.com/circuit-synth/circuit-synth)**: Comprehensive circuit design automation
-- **[kicad-skip](https://github.com/psychogenic/kicad-skip)**: Foundation S-expression parser
+- **[sexpdata](https://github.com/jd-boyd/sexpdata)**: S-expression parsing library
 
 ---
 

kicad_sch_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+kicad_sch_api/__init__.py,sha256=mogTeOic6O-WWOfpoRuBzPicVNha-gbdMrhJX4ir5PY,2821
+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/components.py,sha256=TiQrl7jdDTnuCWKdrlQC8-3b9PU58KoxTTnPX6VyZZk,24759
+kicad_sch_api/core/formatter.py,sha256=WhJPII8-hd4ou3_4AYa4UB8704cEE8rLshhBhVHnY7I,14173
+kicad_sch_api/core/ic_manager.py,sha256=5pw0FtUBXeF6afbiYej7kQe6ga32N4bNTScEHWYGq7A,7298
+kicad_sch_api/core/junctions.py,sha256=p99iv8pBb-3oktVsTeHgjl7QkkZa9EeN32nSy4g23o4,6251
+kicad_sch_api/core/parser.py,sha256=xVWzRwGPklROWe9_VoauVeoFsCZjKQGyo6AsSg0bqgU,44174
+kicad_sch_api/core/schematic.py,sha256=JxOTHbASxcOVEFK2Ms1s7q7uERaKVQb0Ojomfyip99I,45176
+kicad_sch_api/core/types.py,sha256=sn6_OnOKnNjc_6oXpASEfWI6f7oHsMyJaHk8kc3QFMk,12823
+kicad_sch_api/core/wires.py,sha256=kvANBg79KxOd5TKZNpHbjMyouZbGwRKLPNz4ePvvHgk,8207
+kicad_sch_api/library/__init__.py,sha256=NG9UTdcpn25Bl9tPsYs9ED7bvpaVPVdtLMbnxkQkOnU,250
+kicad_sch_api/library/cache.py,sha256=NPJT-apWH_JfVG1aXJ0gDnfGu8es_2tYiyZr-chcTxY,33511
+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.1.0.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
+kicad_sch_api-0.1.0.dist-info/METADATA,sha256=LIRlM5Iev8fS3Elb0zynJXiZIwmIqmUqcaYmnKN8WdA,6674
+kicad_sch_api-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kicad_sch_api-0.1.0.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
+kicad_sch_api-0.1.0.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
+kicad_sch_api-0.1.0.dist-info/RECORD,,

kicad_sch_api-0.0.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-kicad_sch_api/__init__.py,sha256=mogTeOic6O-WWOfpoRuBzPicVNha-gbdMrhJX4ir5PY,2821
-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/components.py,sha256=P_-qZPNpA8LAT0M3dLHFF6XSFyNAnSlcKjUf6aREdUo,22425
-kicad_sch_api/core/formatter.py,sha256=MVF3Hhc5ZVPyVDYnGcxb88q0x0UTr2DQa45gppiFqNk,11953
-kicad_sch_api/core/parser.py,sha256=Ao1j8JPWHGBkznUi9k-RO4_sLcCrkE_5ialSxZAd0cQ,17943
-kicad_sch_api/core/schematic.py,sha256=O76nZvj4qffHkFrMJV5Z35xU95efPW-_mtAD8Nni7ao,15553
-kicad_sch_api/core/types.py,sha256=VyzloTl4RbjMKj0TKu5rEZ-rtxtiT8nvQw8L6xawEvs,9980
-kicad_sch_api/library/__init__.py,sha256=NG9UTdcpn25Bl9tPsYs9ED7bvpaVPVdtLMbnxkQkOnU,250
-kicad_sch_api/library/cache.py,sha256=_JtzEGgO7ViIKF4W2zVrvmHQBIiosp9hOr9pG06Tw6I,18917
-kicad_sch_api/utils/__init__.py,sha256=1V_yGgI7jro6MUc4Pviux_WIeJ1wmiYFID186SZwWLQ,277
-kicad_sch_api/utils/validation.py,sha256=7QZBtPHKu24SA6Bhkj7M-rxs76AVQZWhISDfsJYfV_0,15620
-kicad_sch_api-0.0.2.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
-kicad_sch_api-0.0.2.dist-info/METADATA,sha256=0wa5C_1GHCirtAdlUTh2Eqqa1AreZkeTts6WkQaNjd8,6810
-kicad_sch_api-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kicad_sch_api-0.0.2.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
-kicad_sch_api-0.0.2.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
-kicad_sch_api-0.0.2.dist-info/RECORD,,