kicad-sch-api 0.0.1__py3-none-any.whl

kicad_sch_api/utils/validation.py

@@ -0,0 +1,447 @@
+"""
+Validation utilities for KiCAD schematic manipulation.
+
+This module provides comprehensive validation capabilities including error collection,
+syntax validation, and semantic checking for schematic operations.
+"""
+
+import logging
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Union
+
+logger = logging.getLogger(__name__)
+
+
+class ValidationLevel(Enum):
+    """Validation issue severity levels."""
+
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+
+@dataclass
+class ValidationIssue:
+    """Single validation issue with context."""
+
+    category: str  # e.g., "syntax", "reference", "connection"
+    message: str  # Human-readable description
+    level: ValidationLevel
+    context: Optional[Dict[str, Any]] = None  # Additional context data
+    suggestion: Optional[str] = None  # Suggested fix
+
+    def __post_init__(self):
+        if isinstance(self.level, str):
+            self.level = ValidationLevel(self.level)
+
+    def __str__(self) -> str:
+        context_str = f" ({self.context})" if self.context else ""
+        suggestion_str = f" Suggestion: {self.suggestion}" if self.suggestion else ""
+        return f"{self.level.value.upper()}: {self.category}: {self.message}{context_str}{suggestion_str}"
+
+
+class ValidationError(Exception):
+    """Exception raised when critical validation errors are found."""
+
+    def __init__(self, message: str, issues: List[ValidationIssue] = None):
+        super().__init__(message)
+        self.issues = issues or []
+
+    def add_issue(self, issue: ValidationIssue):
+        """Add a validation issue to this error."""
+        self.issues.append(issue)
+
+    def get_errors(self) -> List[ValidationIssue]:
+        """Get only error-level issues."""
+        return [
+            issue
+            for issue in self.issues
+            if issue.level in (ValidationLevel.ERROR, ValidationLevel.CRITICAL)
+        ]
+
+    def get_warnings(self) -> List[ValidationIssue]:
+        """Get only warning-level issues."""
+        return [issue for issue in self.issues if issue.level == ValidationLevel.WARNING]
+
+
+class SchematicValidator:
+    """
+    Comprehensive validator for schematic data structures and operations.
+
+    Provides validation for:
+    - S-expression syntax
+    - Component references and properties
+    - Library references
+    - Basic electrical connectivity
+    """
+
+    def __init__(self, strict: bool = False):
+        """
+        Initialize validator.
+
+        Args:
+            strict: If True, warnings are treated as errors
+        """
+        self.strict = strict
+        self.issues = []
+        self._valid_reference_pattern = re.compile(r"^[A-Z]+[0-9]*$")
+        self._valid_lib_id_pattern = re.compile(r"^[^:]+:[^:]+$")
+
+    def validate_schematic_data(self, schematic_data: Dict[str, Any]) -> List[ValidationIssue]:
+        """
+        Validate complete schematic data structure.
+
+        Args:
+            schematic_data: Parsed schematic data
+
+        Returns:
+            List of validation issues found
+        """
+        self.issues.clear()
+
+        # Validate basic structure
+        self._validate_basic_structure(schematic_data)
+
+        # Validate components
+        components = schematic_data.get("components", [])
+        self._validate_components(components)
+
+        # Validate references are unique
+        self._validate_unique_references(components)
+
+        # Validate wires and connections
+        wires = schematic_data.get("wires", [])
+        self._validate_wires(wires)
+
+        # Validate nets
+        nets = schematic_data.get("nets", [])
+        self._validate_nets(nets, components)
+
+        return self.issues.copy()
+
+    def validate_component(self, component_data: Dict[str, Any]) -> List[ValidationIssue]:
+        """Validate a single component."""
+        self.issues.clear()
+        self._validate_single_component(component_data)
+        return self.issues.copy()
+
+    def validate_reference(self, reference: str) -> bool:
+        """
+        Validate component reference format.
+
+        Args:
+            reference: Reference to validate (e.g., "R1", "U5")
+
+        Returns:
+            True if reference is valid
+        """
+        if not reference:
+            return False
+        return bool(self._valid_reference_pattern.match(reference))
+
+    def validate_lib_id(self, lib_id: str) -> bool:
+        """
+        Validate library ID format.
+
+        Args:
+            lib_id: Library ID to validate (e.g., "Device:R")
+
+        Returns:
+            True if lib_id is valid
+        """
+        if not lib_id:
+            return False
+        return bool(self._valid_lib_id_pattern.match(lib_id))
+
+    def _validate_basic_structure(self, data: Dict[str, Any]):
+        """Validate basic schematic structure."""
+        required_fields = ["version", "components"]
+
+        for field in required_fields:
+            if field not in data:
+                self.issues.append(
+                    ValidationIssue(
+                        category="structure",
+                        message=f"Missing required field: {field}",
+                        level=ValidationLevel.ERROR,
+                    )
+                )
+
+        # Check version format
+        version = data.get("version")
+        if version and not isinstance(version, (int, str)):
+            self.issues.append(
+                ValidationIssue(
+                    category="structure",
+                    message=f"Invalid version type: {type(version)}",
+                    level=ValidationLevel.WARNING,
+                    suggestion="Version should be string or number",
+                )
+            )
+
+    def _validate_components(self, components: List[Dict[str, Any]]):
+        """Validate all components in schematic."""
+        if not isinstance(components, list):
+            self.issues.append(
+                ValidationIssue(
+                    category="components",
+                    message="Components must be a list",
+                    level=ValidationLevel.ERROR,
+                )
+            )
+            return
+
+        for i, component in enumerate(components):
+            try:
+                self._validate_single_component(component, f"component[{i}]")
+            except Exception as e:
+                self.issues.append(
+                    ValidationIssue(
+                        category="components",
+                        message=f"Error validating component {i}: {e}",
+                        level=ValidationLevel.ERROR,
+                        context={"component_index": i},
+                    )
+                )
+
+    def _validate_single_component(self, component: Dict[str, Any], context: str = "component"):
+        """Validate a single component structure."""
+        required_fields = ["lib_id", "reference", "position"]
+
+        for field in required_fields:
+            if field not in component:
+                self.issues.append(
+                    ValidationIssue(
+                        category="component",
+                        message=f"{context}: Missing required field: {field}",
+                        level=ValidationLevel.ERROR,
+                        context={"field": field},
+                    )
+                )
+
+        # Validate reference format
+        reference = component.get("reference")
+        if reference and not self.validate_reference(reference):
+            self.issues.append(
+                ValidationIssue(
+                    category="reference",
+                    message=f"{context}: Invalid reference format: {reference}",
+                    level=ValidationLevel.ERROR,
+                    context={"reference": reference},
+                    suggestion="Reference should match pattern: [A-Z]+[0-9]*",
+                )
+            )
+
+        # Validate lib_id format
+        lib_id = component.get("lib_id")
+        if lib_id and not self.validate_lib_id(lib_id):
+            self.issues.append(
+                ValidationIssue(
+                    category="lib_id",
+                    message=f"{context}: Invalid lib_id format: {lib_id}",
+                    level=ValidationLevel.ERROR,
+                    context={"lib_id": lib_id},
+                    suggestion="lib_id should match pattern: Library:Symbol",
+                )
+            )
+
+        # Validate position
+        position = component.get("position")
+        if position:
+            self._validate_position(position, f"{context}.position")
+
+        # Validate UUID if present
+        uuid = component.get("uuid")
+        if uuid and not self._validate_uuid(uuid):
+            self.issues.append(
+                ValidationIssue(
+                    category="uuid",
+                    message=f"{context}: Invalid UUID format: {uuid}",
+                    level=ValidationLevel.WARNING,
+                    context={"uuid": uuid},
+                )
+            )
+
+    def _validate_position(self, position: Any, context: str):
+        """Validate position data."""
+        if hasattr(position, "x") and hasattr(position, "y"):
+            # Point object
+            try:
+                float(position.x)
+                float(position.y)
+            except (TypeError, ValueError):
+                self.issues.append(
+                    ValidationIssue(
+                        category="position",
+                        message=f"{context}: Position coordinates must be numeric",
+                        level=ValidationLevel.ERROR,
+                        context={"position": str(position)},
+                    )
+                )
+        else:
+            self.issues.append(
+                ValidationIssue(
+                    category="position",
+                    message=f"{context}: Invalid position format",
+                    level=ValidationLevel.ERROR,
+                    context={"position": position},
+                    suggestion="Position should be Point object with x,y coordinates",
+                )
+            )
+
+    def _validate_unique_references(self, components: List[Dict[str, Any]]):
+        """Validate that all component references are unique."""
+        references = []
+        duplicates = set()
+
+        for component in components:
+            ref = component.get("reference")
+            if ref:
+                if ref in references:
+                    duplicates.add(ref)
+                references.append(ref)
+
+        for ref in duplicates:
+            self.issues.append(
+                ValidationIssue(
+                    category="reference",
+                    message=f"Duplicate component reference: {ref}",
+                    level=ValidationLevel.ERROR,
+                    context={"reference": ref},
+                    suggestion="Each component must have a unique reference",
+                )
+            )
+
+    def _validate_wires(self, wires: List[Dict[str, Any]]):
+        """Validate wire connections."""
+        for i, wire in enumerate(wires):
+            context = f"wire[{i}]"
+
+            # Validate start and end points
+            for point_name in ["start", "end"]:
+                point = wire.get(point_name)
+                if point:
+                    self._validate_position(point, f"{context}.{point_name}")
+
+            # Validate wire has valid length
+            start = wire.get("start")
+            end = wire.get("end")
+            if start and end and hasattr(start, "x") and hasattr(end, "x"):
+                if start.x == end.x and start.y == end.y:
+                    self.issues.append(
+                        ValidationIssue(
+                            category="wire",
+                            message=f"{context}: Wire has zero length",
+                            level=ValidationLevel.WARNING,
+                            context={"start": str(start), "end": str(end)},
+                        )
+                    )
+
+    def _validate_nets(self, nets: List[Dict[str, Any]], components: List[Dict[str, Any]]):
+        """Validate electrical nets."""
+        component_refs = {comp.get("reference") for comp in components if comp.get("reference")}
+
+        for i, net in enumerate(nets):
+            context = f"net[{i}]"
+
+            # Validate net has connections
+            connections = net.get("components", [])
+            if not connections:
+                self.issues.append(
+                    ValidationIssue(
+                        category="net",
+                        message=f"{context}: Net has no connections",
+                        level=ValidationLevel.WARNING,
+                        context={"net_name": net.get("name", "unnamed")},
+                    )
+                )
+
+            # Validate all referenced components exist
+            for ref, pin in connections:
+                if ref not in component_refs:
+                    self.issues.append(
+                        ValidationIssue(
+                            category="net",
+                            message=f"{context}: References non-existent component: {ref}",
+                            level=ValidationLevel.ERROR,
+                            context={"reference": ref, "net_name": net.get("name", "unnamed")},
+                        )
+                    )
+
+    def _validate_uuid(self, uuid_str: str) -> bool:
+        """Validate UUID format."""
+        uuid_pattern = re.compile(
+            r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE
+        )
+        return bool(uuid_pattern.match(uuid_str))
+
+    def has_errors(self) -> bool:
+        """Check if any error-level issues were found."""
+        return any(
+            issue.level in (ValidationLevel.ERROR, ValidationLevel.CRITICAL)
+            for issue in self.issues
+        )
+
+    def has_warnings(self) -> bool:
+        """Check if any warning-level issues were found."""
+        return any(issue.level == ValidationLevel.WARNING for issue in self.issues)
+
+    def get_summary(self) -> Dict[str, int]:
+        """Get summary of validation issues by level."""
+        summary = {level.value: 0 for level in ValidationLevel}
+        for issue in self.issues:
+            summary[issue.level.value] += 1
+        return summary
+
+
+def validate_schematic_file(file_path: str) -> List[ValidationIssue]:
+    """
+    Convenience function to validate a schematic file.
+
+    Args:
+        file_path: Path to .kicad_sch file
+
+    Returns:
+        List of validation issues
+    """
+    from ..core.parser import SExpressionParser
+
+    parser = SExpressionParser()
+    try:
+        schematic_data = parser.parse_file(file_path)
+        validator = SchematicValidator()
+        return validator.validate_schematic_data(schematic_data)
+    except Exception as e:
+        return [
+            ValidationIssue(
+                category="file",
+                message=f"Failed to validate file {file_path}: {e}",
+                level=ValidationLevel.CRITICAL,
+            )
+        ]
+
+
+def collect_validation_errors(func):
+    """
+    Decorator to collect validation errors from operations.
+
+    Usage:
+        @collect_validation_errors
+        def my_operation():
+            # ... operation that might have validation issues
+    """
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except ValidationError as e:
+            logger.error(f"Validation failed in {func.__name__}: {e}")
+            # Log individual issues
+            for issue in e.issues:
+                logger.warning(f"  {issue}")
+            raise
+
+    return wrapper

kicad_sch_api-0.0.1.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: kicad-sch-api
+Version: 0.0.1
+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
+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
+Project-URL: Bug Reports, https://github.com/circuit-synth/kicad-sch-api/issues
+Project-URL: Changelog, https://github.com/circuit-synth/kicad-sch-api/blob/main/CHANGELOG.md
+Keywords: kicad,schematic,eda,electronics,circuit-design,ai,mcp,automation,pcb
+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
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sexpdata>=0.0.3
+Requires-Dist: typing-extensions>=4.0.0; python_version < "3.11"
+Provides-Extra: mcp
+Requires-Dist: mcp>=0.1.0; extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0.0; extra == "docs"
+Requires-Dist: myst-parser>=0.18.0; extra == "docs"
+Dynamic: license-file
+
+# kicad-sch-api
+
+**Professional KiCAD Schematic Manipulation Library with AI Agent Integration**
+
+A modern, high-performance Python library for programmatic manipulation of KiCAD schematic files (.kicad_sch) with exact format preservation, enhanced component management, and native AI agent support via Model Context Protocol (MCP).
+
+## 🚀 Key Features
+
+- **📋 Exact Format Preservation**: Output matches KiCAD's native formatting exactly
+- **⚡ High Performance**: Optimized for large schematics with symbol caching
+- **🤖 AI Agent Integration**: Native MCP server for seamless AI agent interaction
+- **🔧 Enhanced API**: Intuitive object-oriented interface with bulk operations
+- **📚 Advanced Library Management**: Multi-source symbol lookup and caching
+- **✅ Professional Validation**: Comprehensive error collection and reporting
+- **🎯 KiCAD 9 Optimized**: Built specifically for latest KiCAD format
+
+## 🆚 vs. Existing Solutions
+
+| Feature | kicad-sch-api | kicad-skip | KiCAD Official API |
+|---------|---------------|------------|-------------------|
+| **Schematic Support** | ✅ Full | ✅ Full | ❌ PCB Only |
+| **Format Preservation** | ✅ Exact | ❌ Basic | N/A |
+| **Performance** | ✅ Optimized | ⚠️ Basic | N/A |
+| **AI Integration** | ✅ Native MCP | ❌ None | ❌ None |
+| **Library Management** | ✅ Advanced | ⚠️ Basic | N/A |
+| **Runtime Dependencies** | ❌ None | ❌ None | ✅ KiCAD Required |
+
+## 📦 Installation
+
+```bash
+# Install from PyPI (coming soon)
+pip install kicad-sch-api
+
+# Or install from source
+git clone https://github.com/circuit-synth/kicad-sch-api.git
+cd kicad-sch-api/python
+pip install -e .
+
+# For AI agent integration (MCP server)
+cd ../mcp-server
+npm install
+npm run build
+```
+
+## 🎯 Quick Start
+
+### Basic Schematic Manipulation
+
+```python
+import kicad_sch_api as ksa
+
+# Load existing schematic
+sch = ksa.load_schematic('my_circuit.kicad_sch')
+
+# 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))
+
+# 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
+```
+
+### Advanced Operations
+
+```python
+# Bulk operations for large schematics
+resistors = sch.components.filter(lib_id='Device:R')
+for r in resistors:
+    r.set_property('Tolerance', '1%')
+
+# Search and analysis
+power_components = sch.components.in_area(0, 0, 50, 50)
+high_value_resistors = sch.components.filter(
+    lib_id='Device:R', 
+    value_pattern='*k'  # Components with 'k' in value
+)
+
+# Validation and error checking
+issues = sch.validate()
+if issues:
+    print(f"Found {len(issues)} validation issues:")
+    for issue in issues:
+        print(f"  {issue}")
+
+# Performance statistics
+stats = sch.get_performance_stats()
+print(f"Cache hit rate: {stats['symbol_cache']['hit_rate_percent']}%")
+```
+
+### AI Agent Integration (MCP)
+
+Configure in Claude Desktop or compatible MCP client:
+
+```json
+{
+  "kicad-sch": {
+    "command": "node",
+    "args": ["/path/to/kicad-sch-api/mcp-server/dist/index.js"],
+    "env": {
+      "PYTHON_PATH": "python3",
+      "KICAD_SCH_API_PATH": "/path/to/kicad-sch-api/python"
+    }
+  }
+}
+```
+
+Then use natural language with your AI agent:
+
+```
+User: "Create a voltage divider circuit with two 10k resistors"
+
+Claude: I'll create a voltage divider circuit for you.
+
+[Agent automatically uses MCP tools to:]
+1. Create new schematic
+2. Add R1 (10k resistor) at (100, 100)
+3. Add R2 (10k resistor) at (100, 150) 
+4. Connect components with wires
+5. Add voltage input and output labels
+6. Save schematic with exact formatting
+
+Your voltage divider circuit is ready! The circuit provides 50% voltage division
+with two 10kΩ resistors in series configuration.
+```
+
+## 🏗️ Architecture
+
+The library consists of two main components:
+
+### Python Library (Core)
+- **Enhanced Object Model**: Intuitive API with fast component collections
+- **Exact Format Preservation**: S-expression writer that matches KiCAD output
+- **Symbol Caching**: High-performance library symbol management
+- **Comprehensive Validation**: Error collection and professional reporting
+
+### MCP Server (AI Integration)
+- **TypeScript MCP Server**: Implements Anthropic's MCP specification
+- **Python Bridge**: Reliable subprocess communication
+- **Comprehensive Tools**: 15+ tools for complete schematic manipulation
+- **Professional Error Handling**: Detailed error context for AI agents
+
+## 🧪 Testing & Quality
+
+```bash
+# Python tests
+cd python
+python -m pytest tests/ -v --cov=kicad_sch_api
+
+# MCP server tests  
+cd mcp-server
+npm test
+
+# Format preservation tests
+python -m pytest tests/test_format_preservation.py -v
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## 📄 License
+
+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
+
+---
+
+**Built with ❤️ by the Circuit-Synth team**

kicad_sch_api-0.0.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+kicad_sch_api/__init__.py,sha256=kvc92hzeQ6mSe3AsXSbK-CvGgoXtljyUCrzJcmBa-ao,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=_sw8Hh2eemGHzYcjGoFrBeufX05G1JfO5inYMQDQD9k,22100
+kicad_sch_api/core/formatter.py,sha256=MVF3Hhc5ZVPyVDYnGcxb88q0x0UTr2DQa45gppiFqNk,11953
+kicad_sch_api/core/parser.py,sha256=x7aMqnsDO4Y2VJtYvgrrJJVi2r8SAFUjSCVtMIDVWDY,16652
+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/mcp/__init__.py,sha256=dVit9lqiieujSYkyvfycE8JTo0AEWMI4plNxCK9pSD0,128
+kicad_sch_api/mcp/server.py,sha256=wGTdXPF6mMA8JoP-HiDUg7XJ21Dfr0ZoThB3WqKM_fQ,19079
+kicad_sch_api/utils/__init__.py,sha256=1V_yGgI7jro6MUc4Pviux_WIeJ1wmiYFID186SZwWLQ,277
+kicad_sch_api/utils/validation.py,sha256=i7VvhMaYxrb8wxddf0S3vvpDE7r8ldM53CDqF9-ARqI,15557
+kicad_sch_api-0.0.1.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
+kicad_sch_api-0.0.1.dist-info/METADATA,sha256=jrEKEblgqF95O2aXEdzpuZhGm1gFp4RFFe3DKU86GeQ,7643
+kicad_sch_api-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kicad_sch_api-0.0.1.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
+kicad_sch_api-0.0.1.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
+kicad_sch_api-0.0.1.dist-info/RECORD,,

kicad_sch_api-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+