kicad-sch-api 0.3.2__tar.gz → 0.3.5__tar.gz

{kicad_sch_api-0.3.2/kicad_sch_api.egg-info → kicad_sch_api-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.3.2
+Version: 0.3.5
 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>

kicad_sch_api-0.3.5/examples/parser_demo.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Demonstration of the new modular parser system.
+
+This example shows how to use the new ElementParserRegistry
+and specialized parsers for different S-expression elements.
+"""
+
+import logging
+import sexpdata
+
+from kicad_sch_api.parsers.registry import ElementParserRegistry
+from kicad_sch_api.parsers.wire_parser import WireParser
+from kicad_sch_api.parsers.symbol_parser import SymbolParser
+from kicad_sch_api.parsers.label_parser import LabelParser, HierarchicalLabelParser
+
+# Enable debug logging to see what's happening
+logging.basicConfig(level=logging.WARNING)  # Reduce noise
+
+
+def main():
+    """Demonstrate the new parser system."""
+    print("🔧 KiCAD Schematic API - New Parser System Demo")
+    print("=" * 50)
+
+    # Create registry and register specialized parsers
+    registry = ElementParserRegistry()
+    registry.register("wire", WireParser())
+    registry.register("symbol", SymbolParser())
+    registry.register("label", LabelParser())
+    registry.register("hierarchical_label", HierarchicalLabelParser())
+
+    print(f"📋 Registered parsers: {registry.get_registered_types()}")
+    print()
+
+    # Example S-expression elements (using sexpdata.Symbol for type names)
+    test_elements = [
+        # Wire element
+        [sexpdata.Symbol("wire"),
+         [sexpdata.Symbol("pts"), [sexpdata.Symbol("xy"), 100.0, 100.0], [sexpdata.Symbol("xy"), 150.0, 100.0]],
+         [sexpdata.Symbol("stroke"), [sexpdata.Symbol("width"), 0.0], [sexpdata.Symbol("type"), sexpdata.Symbol("default")]],
+         [sexpdata.Symbol("uuid"), "12345678-1234-5678-9abc-123456789abc"]],
+
+        # Label element
+        [sexpdata.Symbol("label"), "VCC",
+         [sexpdata.Symbol("at"), 125.0, 95.0, 0],
+         [sexpdata.Symbol("effects"), [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]]],
+         [sexpdata.Symbol("uuid"), "87654321-4321-8765-cba9-876543210987"]],
+
+        # Unknown element (will be skipped)
+        [sexpdata.Symbol("unknown_element"), "some_data"]
+    ]
+
+    # Parse elements using the registry
+    print("🔍 Parsing S-expression elements:")
+    print()
+
+    for i, element in enumerate(test_elements, 1):
+        element_type = element[0] if element else "unknown"
+        print(f"Element {i}: {element_type}")
+
+        result = registry.parse_element(element)
+        if result:
+            print(f"  ✅ Successfully parsed")
+            print(f"  📊 Result keys: {list(result.keys())}")
+            if "points" in result:
+                print(f"  📍 Points: {len(result['points'])} points")
+            if "text" in result:
+                print(f"  📝 Text: '{result['text']}'")
+        else:
+            print(f"  ❌ No parser available")
+        print()
+
+    # Demonstrate batch parsing
+    print("📦 Batch parsing multiple elements:")
+    results = registry.parse_elements(test_elements)
+    print(f"  ✅ Successfully parsed {len(results)} of {len(test_elements)} elements")
+
+    # Show parsing statistics
+    successful_types = [r.get("type", "unknown") for r in results if "type" in r]
+    print(f"  📊 Parsed types: {set(successful_types)}")
+
+    print()
+    print("✨ New parser system benefits:")
+    print("  • Modular and testable parsers")
+    print("  • Easy to add new element types")
+    print("  • Clear separation of concerns")
+    print("  • Comprehensive error handling")
+    print("  • Extensible with fallback parsers")
+
+
+if __name__ == "__main__":
+    main()

{kicad_sch_api-0.3.2 → kicad_sch_api-0.3.5}/kicad_sch_api/__init__.py

@@ -42,7 +42,7 @@ Advanced Usage:
         print(f"Found {len(issues)} validation issues")
 """
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"
 __author__ = "Circuit-Synth"
 __email__ = "info@circuit-synth.com"
 
@@ -55,7 +55,7 @@ from .library.cache import SymbolLibraryCache, get_symbol_cache
 from .utils.validation import ValidationError, ValidationIssue
 
 # Version info
-VERSION_INFO = (0, 3, 2)
+VERSION_INFO = (0, 3, 3)
 
 # Public API
 __all__ = [

kicad_sch_api-0.3.5/kicad_sch_api/collections/__init__.py

@@ -0,0 +1,21 @@
+"""
+Modern collection architecture for KiCAD schematic elements.
+
+This module provides a unified collection framework that eliminates code duplication
+across component, wire, and junction collections while providing consistent
+indexing, performance optimization, and management capabilities.
+"""
+
+from .base import IndexedCollection
+from .components import ComponentCollection
+from .wires import WireCollection
+from .junctions import JunctionCollection
+from .labels import LabelCollection
+
+__all__ = [
+    "IndexedCollection",
+    "ComponentCollection",
+    "WireCollection",
+    "JunctionCollection",
+    "LabelCollection",
+]

kicad_sch_api-0.3.5/kicad_sch_api/collections/base.py

@@ -0,0 +1,296 @@
+"""
+Base collection class for unified schematic element management.
+
+Provides common functionality for indexing, searching, and managing
+collections of schematic elements with performance optimization.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, Generic, Iterator, List, Optional, TypeVar, Union
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T')  # Type variable for collection items
+
+
+class IndexedCollection(Generic[T], ABC):
+    """
+    Base class for all schematic element collections with automatic indexing.
+
+    Provides unified functionality for:
+    - UUID-based fast lookups
+    - Automatic index management
+    - Modification tracking
+    - Consistent iteration interface
+    - Performance optimization for large collections
+    """
+
+    def __init__(self, items: Optional[List[T]] = None):
+        """
+        Initialize indexed collection.
+
+        Args:
+            items: Initial list of items to add to collection
+        """
+        self._items: List[T] = []
+        self._uuid_index: Dict[str, int] = {}
+        self._modified = False
+        self._dirty_indexes = False
+
+        # Add initial items if provided
+        if items:
+            for item in items:
+                self._add_item_to_collection(item)
+
+        logger.debug(f"{self.__class__.__name__} initialized with {len(self._items)} items")
+
+    # Abstract methods for subclasses to implement
+    @abstractmethod
+    def _get_item_uuid(self, item: T) -> str:
+        """
+        Extract UUID from an item.
+
+        Args:
+            item: Item to extract UUID from
+
+        Returns:
+            UUID string for the item
+        """
+        pass
+
+    @abstractmethod
+    def _create_item(self, **kwargs) -> T:
+        """
+        Create a new item with given parameters.
+
+        Args:
+            **kwargs: Parameters for item creation
+
+        Returns:
+            Newly created item
+        """
+        pass
+
+    @abstractmethod
+    def _build_additional_indexes(self) -> None:
+        """
+        Build any additional indexes specific to the collection type.
+
+        Called after UUID index is rebuilt. Subclasses should implement
+        this to maintain their own specialized indexes.
+        """
+        pass
+
+    # Core collection operations
+    def add(self, item: T) -> T:
+        """
+        Add an item to the collection.
+
+        Args:
+            item: Item to add
+
+        Returns:
+            The added item
+
+        Raises:
+            ValueError: If item with same UUID already exists
+        """
+        uuid_str = self._get_item_uuid(item)
+
+        # Ensure indexes are current before checking for duplicates
+        self._ensure_indexes_current()
+
+        # Check for duplicate UUID
+        if uuid_str in self._uuid_index:
+            raise ValueError(f"Item with UUID {uuid_str} already exists")
+
+        return self._add_item_to_collection(item)
+
+    def remove(self, identifier: Union[str, T]) -> bool:
+        """
+        Remove an item from the collection.
+
+        Args:
+            identifier: UUID string or item instance to remove
+
+        Returns:
+            True if item was removed, False if not found
+        """
+        self._ensure_indexes_current()
+
+        if isinstance(identifier, str):
+            # Remove by UUID
+            if identifier not in self._uuid_index:
+                return False
+
+            index = self._uuid_index[identifier]
+            item = self._items[index]
+        else:
+            # Remove by item instance
+            item = identifier
+            uuid_str = self._get_item_uuid(item)
+            if uuid_str not in self._uuid_index:
+                return False
+
+            index = self._uuid_index[uuid_str]
+
+        # Remove from main list
+        self._items.pop(index)
+        self._mark_modified()
+        self._mark_indexes_dirty()
+
+        logger.debug(f"Removed item with UUID {self._get_item_uuid(item)}")
+        return True
+
+    def get(self, uuid: str) -> Optional[T]:
+        """
+        Get an item by UUID.
+
+        Args:
+            uuid: UUID to search for
+
+        Returns:
+            Item if found, None otherwise
+        """
+        self._ensure_indexes_current()
+
+        if uuid in self._uuid_index:
+            index = self._uuid_index[uuid]
+            return self._items[index]
+
+        return None
+
+    def find(self, predicate: Callable[[T], bool]) -> List[T]:
+        """
+        Find all items matching a predicate.
+
+        Args:
+            predicate: Function that returns True for matching items
+
+        Returns:
+            List of matching items
+        """
+        return [item for item in self._items if predicate(item)]
+
+    def filter(self, **criteria) -> List[T]:
+        """
+        Filter items by attribute criteria.
+
+        Args:
+            **criteria: Attribute name/value pairs to match
+
+        Returns:
+            List of matching items
+        """
+        def matches_criteria(item: T) -> bool:
+            for attr, value in criteria.items():
+                if not hasattr(item, attr) or getattr(item, attr) != value:
+                    return False
+            return True
+
+        return self.find(matches_criteria)
+
+    def clear(self) -> None:
+        """Clear all items from the collection."""
+        self._items.clear()
+        self._uuid_index.clear()
+        self._mark_modified()
+        logger.debug(f"Cleared all items from {self.__class__.__name__}")
+
+    # Collection interface methods
+    def __len__(self) -> int:
+        """Number of items in collection."""
+        return len(self._items)
+
+    def __iter__(self) -> Iterator[T]:
+        """Iterate over items in collection."""
+        return iter(self._items)
+
+    def __contains__(self, item: Union[str, T]) -> bool:
+        """Check if item or UUID is in collection."""
+        if isinstance(item, str):
+            # Check by UUID
+            self._ensure_indexes_current()
+            return item in self._uuid_index
+        else:
+            # Check by item instance
+            uuid_str = self._get_item_uuid(item)
+            self._ensure_indexes_current()
+            return uuid_str in self._uuid_index
+
+    def __getitem__(self, index: int) -> T:
+        """Get item by index."""
+        return self._items[index]
+
+    # Internal methods
+    def _add_item_to_collection(self, item: T) -> T:
+        """
+        Internal method to add item to collection.
+
+        Args:
+            item: Item to add
+
+        Returns:
+            The added item
+        """
+        self._items.append(item)
+        self._mark_modified()
+        self._mark_indexes_dirty()
+
+        logger.debug(f"Added item with UUID {self._get_item_uuid(item)}")
+        return item
+
+    def _mark_modified(self) -> None:
+        """Mark collection as modified."""
+        self._modified = True
+
+    def _mark_indexes_dirty(self) -> None:
+        """Mark indexes as needing rebuild."""
+        self._dirty_indexes = True
+
+    def _ensure_indexes_current(self) -> None:
+        """Ensure all indexes are current."""
+        if self._dirty_indexes:
+            self._rebuild_indexes()
+
+    def _rebuild_indexes(self) -> None:
+        """Rebuild all indexes."""
+        # Rebuild UUID index
+        self._uuid_index = {
+            self._get_item_uuid(item): i
+            for i, item in enumerate(self._items)
+        }
+
+        # Let subclasses rebuild their additional indexes
+        self._build_additional_indexes()
+
+        self._dirty_indexes = False
+        logger.debug(f"Rebuilt indexes for {self.__class__.__name__}")
+
+    # Collection statistics and debugging
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        Get collection statistics for debugging and monitoring.
+
+        Returns:
+            Dictionary with collection statistics
+        """
+        self._ensure_indexes_current()
+        return {
+            "item_count": len(self._items),
+            "uuid_index_size": len(self._uuid_index),
+            "modified": self._modified,
+            "indexes_dirty": self._dirty_indexes,
+            "collection_type": self.__class__.__name__
+        }
+
+    @property
+    def is_modified(self) -> bool:
+        """Whether collection has been modified."""
+        return self._modified
+
+    def mark_clean(self) -> None:
+        """Mark collection as clean (not modified)."""
+        self._modified = False
+        logger.debug(f"Marked {self.__class__.__name__} as clean")