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

kicad_sch_api/core/schematic.py

@@ -11,12 +11,16 @@ import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+import sexpdata
+
 from ..library.cache import get_symbol_cache
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
 from .components import ComponentCollection
 from .formatter import ExactFormatter
 from .parser import SExpressionParser
-from .types import Junction, Label, Net, Point, SchematicSymbol, TitleBlock, Wire
+from .types import Junction, Label, Net, Point, SchematicSymbol, TitleBlock, Wire, LabelType, HierarchicalLabelShape, WireType, Sheet, Text, TextBox
+from .wires import WireCollection
+from .junctions import JunctionCollection
 
 logger = logging.getLogger(__name__)
 
@@ -62,6 +66,54 @@ class Schematic:
         ]
         self._components = ComponentCollection(component_symbols)
 
+        # Initialize wire collection
+        wire_data = self._data.get("wires", [])
+        wires = []
+        for wire_dict in wire_data:
+            if isinstance(wire_dict, dict):
+                # Convert dict to Wire object
+                points = []
+                for point_data in wire_dict.get("points", []):
+                    if isinstance(point_data, dict):
+                        points.append(Point(point_data["x"], point_data["y"]))
+                    elif isinstance(point_data, (list, tuple)):
+                        points.append(Point(point_data[0], point_data[1]))
+                    else:
+                        points.append(point_data)
+                
+                wire = Wire(
+                    uuid=wire_dict.get("uuid", str(uuid.uuid4())),
+                    points=points,
+                    wire_type=WireType(wire_dict.get("wire_type", "wire")),
+                    stroke_width=wire_dict.get("stroke_width", 0.0),
+                    stroke_type=wire_dict.get("stroke_type", "default")
+                )
+                wires.append(wire)
+        self._wires = WireCollection(wires)
+
+        # Initialize junction collection
+        junction_data = self._data.get("junctions", [])
+        junctions = []
+        for junction_dict in junction_data:
+            if isinstance(junction_dict, dict):
+                # Convert dict to Junction object
+                position = junction_dict.get("position", {"x": 0, "y": 0})
+                if isinstance(position, dict):
+                    pos = Point(position["x"], position["y"])
+                elif isinstance(position, (list, tuple)):
+                    pos = Point(position[0], position[1])
+                else:
+                    pos = position
+                
+                junction = Junction(
+                    uuid=junction_dict.get("uuid", str(uuid.uuid4())),
+                    position=pos,
+                    diameter=junction_dict.get("diameter", 0),
+                    color=junction_dict.get("color", (0, 0, 0, 0))
+                )
+                junctions.append(junction)
+        self._junctions = JunctionCollection(junctions)
+
         # Track modifications for save optimization
         self._modified = False
         self._last_save_time = None
@@ -70,7 +122,7 @@ class Schematic:
         self._operation_count = 0
         self._total_operation_time = 0.0
 
-        logger.debug(f"Schematic initialized with {len(self._components)} components")
+        logger.debug(f"Schematic initialized with {len(self._components)} components, {len(self._wires)} wires, and {len(self._junctions)} junctions")
 
     @classmethod
     def load(cls, file_path: Union[str, Path]) -> "Schematic":
@@ -101,19 +153,30 @@ class Schematic:
         return cls(schematic_data, str(file_path))
 
     @classmethod
-    def create(cls, name: str = "Untitled", version: str = "20230121") -> "Schematic":
+    def create(cls, name: str = "Untitled", version: str = "20250114", 
+               generator: str = "eeschema", generator_version: str = "9.0",
+               paper: str = "A4", uuid: str = None) -> "Schematic":
         """
-        Create a new empty schematic.
+        Create a new empty schematic with configurable parameters.
 
         Args:
             name: Schematic name
-            version: KiCAD version string
+            version: KiCAD version (default: "20250114")
+            generator: Generator name (default: "eeschema") 
+            generator_version: Generator version (default: "9.0")
+            paper: Paper size (default: "A4")
+            uuid: Specific UUID (auto-generated if None)
 
         Returns:
             New empty Schematic object
         """
         schematic_data = cls._create_empty_schematic_data()
         schematic_data["version"] = version
+        schematic_data["generator"] = generator
+        schematic_data["generator_version"] = generator_version
+        schematic_data["paper"] = paper
+        if uuid:
+            schematic_data["uuid"] = uuid
         schematic_data["title_block"] = {"title": name}
 
         logger.info(f"Created new schematic: {name}")
@@ -125,6 +188,16 @@ class Schematic:
         """Collection of all components in the schematic."""
         return self._components
 
+    @property
+    def wires(self) -> WireCollection:
+        """Collection of all wires in the schematic."""
+        return self._wires
+
+    @property
+    def junctions(self) -> JunctionCollection:
+        """Collection of all junctions in the schematic."""
+        return self._junctions
+
     @property
     def version(self) -> Optional[str]:
         """KiCAD version string."""
@@ -184,8 +257,10 @@ class Schematic:
         if errors:
             raise ValidationError("Cannot save schematic with validation errors", errors)
 
-        # Update data structure with current component state
+        # Update data structure with current component, wire, and junction state
         self._sync_components_to_data()
+        self._sync_wires_to_data()
+        self._sync_junctions_to_data()
 
         # Write file
         if preserve_format and self._original_content:
@@ -258,6 +333,42 @@ class Schematic:
         issues.extend(component_issues)
 
         return issues
+    
+    # Focused helper functions for specific KiCAD sections
+    def add_lib_symbols_section(self, lib_symbols: Dict[str, Any]):
+        """Add or update lib_symbols section with specific symbol definitions."""
+        self._data["lib_symbols"] = lib_symbols
+        self._modified = True
+    
+    def add_instances_section(self, instances: Dict[str, Any]):
+        """Add instances section for component placement tracking."""
+        self._data["instances"] = instances
+        self._modified = True
+    
+    def add_sheet_instances_section(self, sheet_instances: List[Dict]):
+        """Add sheet_instances section for hierarchical design."""
+        self._data["sheet_instances"] = sheet_instances  
+        self._modified = True
+    
+    def set_paper_size(self, paper: str):
+        """Set paper size (A4, A3, etc.)."""
+        self._data["paper"] = paper
+        self._modified = True
+    
+    def set_version_info(self, version: str, generator: str = "eeschema", generator_version: str = "9.0"):
+        """Set version and generator information."""
+        self._data["version"] = version
+        self._data["generator"] = generator  
+        self._data["generator_version"] = generator_version
+        self._modified = True
+    
+    def copy_metadata_from(self, source_schematic: "Schematic"):
+        """Copy all metadata from another schematic (version, generator, paper, etc.)."""
+        metadata_fields = ["version", "generator", "generator_version", "paper", "uuid", "title_block"]
+        for field in metadata_fields:
+            if field in source_schematic._data:
+                self._data[field] = source_schematic._data[field]
+        self._modified = True
 
     def get_summary(self) -> Dict[str, Any]:
         """Get summary information about the schematic."""
@@ -326,6 +437,382 @@ class Schematic:
                 return True
         return False
 
+    # Label management
+    def add_hierarchical_label(
+        self, 
+        text: str, 
+        position: Union[Point, Tuple[float, float]], 
+        shape: HierarchicalLabelShape = HierarchicalLabelShape.INPUT,
+        rotation: float = 0.0,
+        size: float = 1.27
+    ) -> str:
+        """
+        Add a hierarchical label.
+
+        Args:
+            text: Label text
+            position: Label position
+            shape: Label shape/direction
+            rotation: Text rotation in degrees
+            size: Font size
+
+        Returns:
+            UUID of created hierarchical label
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        label = Label(
+            uuid=str(uuid.uuid4()),
+            position=position,
+            text=text,
+            label_type=LabelType.HIERARCHICAL,
+            rotation=rotation,
+            size=size,
+            shape=shape
+        )
+
+        if "hierarchical_labels" not in self._data:
+            self._data["hierarchical_labels"] = []
+
+        self._data["hierarchical_labels"].append({
+            "uuid": label.uuid,
+            "position": {"x": label.position.x, "y": label.position.y},
+            "text": label.text,
+            "shape": label.shape.value,
+            "rotation": label.rotation,
+            "size": label.size
+        })
+        self._modified = True
+
+        logger.debug(f"Added hierarchical label: {text} at {position}")
+        return label.uuid
+
+    def remove_hierarchical_label(self, label_uuid: str) -> bool:
+        """Remove hierarchical label by UUID."""
+        labels = self._data.get("hierarchical_labels", [])
+        for i, label in enumerate(labels):
+            if label.get("uuid") == label_uuid:
+                del labels[i]
+                self._modified = True
+                logger.debug(f"Removed hierarchical label: {label_uuid}")
+                return True
+        return False
+
+    def add_label(
+        self, 
+        text: str, 
+        position: Union[Point, Tuple[float, float]], 
+        rotation: float = 0.0,
+        size: float = 1.27
+    ) -> str:
+        """
+        Add a local label.
+
+        Args:
+            text: Label text
+            position: Label position
+            rotation: Text rotation in degrees
+            size: Font size
+
+        Returns:
+            UUID of created label
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        label = Label(
+            uuid=str(uuid.uuid4()),
+            position=position,
+            text=text,
+            label_type=LabelType.LOCAL,
+            rotation=rotation,
+            size=size
+        )
+
+        if "labels" not in self._data:
+            self._data["labels"] = []
+
+        self._data["labels"].append({
+            "uuid": label.uuid,
+            "position": {"x": label.position.x, "y": label.position.y},
+            "text": label.text,
+            "rotation": label.rotation,
+            "size": label.size
+        })
+        self._modified = True
+
+        logger.debug(f"Added local label: {text} at {position}")
+        return label.uuid
+
+    def remove_label(self, label_uuid: str) -> bool:
+        """Remove local label by UUID."""
+        labels = self._data.get("labels", [])
+        for i, label in enumerate(labels):
+            if label.get("uuid") == label_uuid:
+                del labels[i]
+                self._modified = True
+                logger.debug(f"Removed local label: {label_uuid}")
+                return True
+        return False
+
+    def add_sheet(
+        self,
+        name: str,
+        filename: str,
+        position: Union[Point, Tuple[float, float]], 
+        size: Union[Point, Tuple[float, float]],
+        stroke_width: float = 0.1524,
+        stroke_type: str = "solid",
+        exclude_from_sim: bool = False,
+        in_bom: bool = True,
+        on_board: bool = True,
+        project_name: str = "",
+        page_number: str = "2"
+    ) -> str:
+        """
+        Add a hierarchical sheet.
+
+        Args:
+            name: Sheet name (displayed above sheet)
+            filename: Sheet filename (.kicad_sch file)
+            position: Sheet position (top-left corner)
+            size: Sheet size (width, height)
+            stroke_width: Border line width
+            stroke_type: Border line type
+            exclude_from_sim: Exclude from simulation
+            in_bom: Include in BOM
+            on_board: Include on board
+            project_name: Project name for instances
+            page_number: Page number for instances
+
+        Returns:
+            UUID of created sheet
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+        if isinstance(size, tuple):
+            size = Point(size[0], size[1])
+
+        sheet = Sheet(
+            uuid=str(uuid.uuid4()),
+            position=position,
+            size=size,
+            name=name,
+            filename=filename,
+            exclude_from_sim=exclude_from_sim,
+            in_bom=in_bom,
+            on_board=on_board,
+            stroke_width=stroke_width,
+            stroke_type=stroke_type
+        )
+
+        if "sheets" not in self._data:
+            self._data["sheets"] = []
+
+        self._data["sheets"].append({
+            "uuid": sheet.uuid,
+            "position": {"x": sheet.position.x, "y": sheet.position.y},
+            "size": {"width": sheet.size.x, "height": sheet.size.y},
+            "name": sheet.name,
+            "filename": sheet.filename,
+            "exclude_from_sim": sheet.exclude_from_sim,
+            "in_bom": sheet.in_bom,
+            "on_board": sheet.on_board,
+            "dnp": sheet.dnp,
+            "fields_autoplaced": sheet.fields_autoplaced,
+            "stroke_width": sheet.stroke_width,
+            "stroke_type": sheet.stroke_type,
+            "fill_color": sheet.fill_color,
+            "pins": [],  # Sheet pins added separately
+            "project_name": project_name,
+            "page_number": page_number
+        })
+        self._modified = True
+
+        logger.debug(f"Added hierarchical sheet: {name} ({filename}) at {position}")
+        return sheet.uuid
+
+    def add_sheet_pin(
+        self,
+        sheet_uuid: str,
+        name: str,
+        pin_type: str = "input",
+        position: Union[Point, Tuple[float, float]] = (0, 0),
+        rotation: float = 0,
+        size: float = 1.27,
+        justify: str = "right"
+    ) -> str:
+        """
+        Add a pin to a hierarchical sheet.
+
+        Args:
+            sheet_uuid: UUID of the sheet to add pin to
+            name: Pin name (NET1, NET2, etc.)
+            pin_type: Pin type (input, output, bidirectional, etc.)
+            position: Pin position relative to sheet
+            rotation: Pin rotation in degrees
+            size: Font size for pin label
+            justify: Text justification (left, right, center)
+
+        Returns:
+            UUID of created sheet pin
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        pin_uuid = str(uuid.uuid4())
+        
+        # Find the sheet in the data
+        sheets = self._data.get("sheets", [])
+        for sheet in sheets:
+            if sheet.get("uuid") == sheet_uuid:
+                # Add pin to the sheet's pins list
+                pin_data = {
+                    "uuid": pin_uuid,
+                    "name": name,
+                    "pin_type": pin_type,
+                    "position": {"x": position.x, "y": position.y},
+                    "rotation": rotation,
+                    "size": size,
+                    "justify": justify
+                }
+                sheet["pins"].append(pin_data)
+                self._modified = True
+                
+                logger.debug(f"Added sheet pin: {name} ({pin_type}) to sheet {sheet_uuid}")
+                return pin_uuid
+        
+        raise ValueError(f"Sheet with UUID '{sheet_uuid}' not found")
+
+    def add_text(
+        self,
+        text: str,
+        position: Union[Point, Tuple[float, float]],
+        rotation: float = 0.0,
+        size: float = 1.27,
+        exclude_from_sim: bool = False
+    ) -> str:
+        """
+        Add a text element.
+
+        Args:
+            text: Text content
+            position: Text position
+            rotation: Text rotation in degrees
+            size: Font size
+            exclude_from_sim: Exclude from simulation
+
+        Returns:
+            UUID of created text element
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        text_element = Text(
+            uuid=str(uuid.uuid4()),
+            position=position,
+            text=text,
+            rotation=rotation,
+            size=size,
+            exclude_from_sim=exclude_from_sim
+        )
+
+        if "texts" not in self._data:
+            self._data["texts"] = []
+
+        self._data["texts"].append({
+            "uuid": text_element.uuid,
+            "position": {"x": text_element.position.x, "y": text_element.position.y},
+            "text": text_element.text,
+            "rotation": text_element.rotation,
+            "size": text_element.size,
+            "exclude_from_sim": text_element.exclude_from_sim
+        })
+        self._modified = True
+
+        logger.debug(f"Added text: '{text}' at {position}")
+        return text_element.uuid
+
+    def add_text_box(
+        self,
+        text: str,
+        position: Union[Point, Tuple[float, float]],
+        size: Union[Point, Tuple[float, float]],
+        rotation: float = 0.0,
+        font_size: float = 1.27,
+        margins: Tuple[float, float, float, float] = (0.9525, 0.9525, 0.9525, 0.9525),
+        stroke_width: float = 0.0,
+        stroke_type: str = "solid",
+        fill_type: str = "none",
+        justify_horizontal: str = "left",
+        justify_vertical: str = "top",
+        exclude_from_sim: bool = False
+    ) -> str:
+        """
+        Add a text box element.
+
+        Args:
+            text: Text content
+            position: Text box position (top-left corner)
+            size: Text box size (width, height)
+            rotation: Text rotation in degrees
+            font_size: Font size
+            margins: Margins (top, right, bottom, left)
+            stroke_width: Border line width
+            stroke_type: Border line type
+            fill_type: Fill type (none, solid, etc.)
+            justify_horizontal: Horizontal text alignment
+            justify_vertical: Vertical text alignment
+            exclude_from_sim: Exclude from simulation
+
+        Returns:
+            UUID of created text box element
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+        if isinstance(size, tuple):
+            size = Point(size[0], size[1])
+
+        text_box = TextBox(
+            uuid=str(uuid.uuid4()),
+            position=position,
+            size=size,
+            text=text,
+            rotation=rotation,
+            font_size=font_size,
+            margins=margins,
+            stroke_width=stroke_width,
+            stroke_type=stroke_type,
+            fill_type=fill_type,
+            justify_horizontal=justify_horizontal,
+            justify_vertical=justify_vertical,
+            exclude_from_sim=exclude_from_sim
+        )
+
+        if "text_boxes" not in self._data:
+            self._data["text_boxes"] = []
+
+        self._data["text_boxes"].append({
+            "uuid": text_box.uuid,
+            "position": {"x": text_box.position.x, "y": text_box.position.y},
+            "size": {"width": text_box.size.x, "height": text_box.size.y},
+            "text": text_box.text,
+            "rotation": text_box.rotation,
+            "font_size": text_box.font_size,
+            "margins": text_box.margins,
+            "stroke_width": text_box.stroke_width,
+            "stroke_type": text_box.stroke_type,
+            "fill_type": text_box.fill_type,
+            "justify_horizontal": text_box.justify_horizontal,
+            "justify_vertical": text_box.justify_vertical,
+            "exclude_from_sim": text_box.exclude_from_sim
+        })
+        self._modified = True
+
+        logger.debug(f"Added text box: '{text}' at {position} size {size}")
+        return text_box.uuid
+
     # Library management
     @property
     def libraries(self) -> "LibraryManager":
@@ -390,14 +877,250 @@ class Schematic:
     def _sync_components_to_data(self):
         """Sync component collection state back to data structure."""
         self._data["components"] = [comp._data.__dict__ for comp in self._components]
+        
+        # Populate lib_symbols with actual symbol definitions used by components
+        lib_symbols = {}
+        cache = get_symbol_cache()
+        
+        for comp in self._components:
+            if comp.lib_id and comp.lib_id not in lib_symbols:
+                logger.debug(f"🔧 SCHEMATIC: Processing component {comp.lib_id}")
+                
+                # Get the actual symbol definition
+                symbol_def = cache.get_symbol(comp.lib_id)
+                if symbol_def:
+                    logger.debug(f"🔧 SCHEMATIC: Loaded symbol {comp.lib_id}")
+                    lib_symbols[comp.lib_id] = self._convert_symbol_to_kicad_format(symbol_def, comp.lib_id)
+                    
+                    # Check if this symbol extends another symbol using multiple methods
+                    extends_parent = None
+                    
+                    # Method 1: Check raw_kicad_data
+                    if hasattr(symbol_def, 'raw_kicad_data') and symbol_def.raw_kicad_data:
+                        extends_parent = self._check_symbol_extends(symbol_def.raw_kicad_data)
+                        logger.debug(f"🔧 SCHEMATIC: Checked raw_kicad_data for {comp.lib_id}, extends: {extends_parent}")
+                    
+                    # Method 2: Check raw_data attribute  
+                    if not extends_parent and hasattr(symbol_def, '__dict__'):
+                        for attr_name, attr_value in symbol_def.__dict__.items():
+                            if attr_name == 'raw_data':
+                                logger.debug(f"🔧 SCHEMATIC: Checking raw_data for extends: {type(attr_value)}")
+                                extends_parent = self._check_symbol_extends(attr_value)
+                                if extends_parent:
+                                    logger.debug(f"🔧 SCHEMATIC: Found extends in raw_data: {extends_parent}")
+                                    
+                    # Method 3: Check the extends attribute directly
+                    if not extends_parent and hasattr(symbol_def, 'extends'):
+                        extends_parent = symbol_def.extends
+                        logger.debug(f"🔧 SCHEMATIC: Found extends attribute: {extends_parent}")
+                    
+                    if extends_parent:
+                        # Load the parent symbol too
+                        parent_lib_id = f"{comp.lib_id.split(':')[0]}:{extends_parent}"
+                        logger.debug(f"🔧 SCHEMATIC: Loading parent symbol: {parent_lib_id}")
+                        
+                        if parent_lib_id not in lib_symbols:
+                            parent_symbol_def = cache.get_symbol(parent_lib_id)
+                            if parent_symbol_def:
+                                lib_symbols[parent_lib_id] = self._convert_symbol_to_kicad_format(parent_symbol_def, parent_lib_id)
+                                logger.debug(f"🔧 SCHEMATIC: Successfully loaded parent symbol: {parent_lib_id} for {comp.lib_id}")
+                            else:
+                                logger.warning(f"🔧 SCHEMATIC: Failed to load parent symbol: {parent_lib_id}")
+                        else:
+                            logger.debug(f"🔧 SCHEMATIC: Parent symbol {parent_lib_id} already loaded")
+                    else:
+                        logger.debug(f"🔧 SCHEMATIC: No extends found for {comp.lib_id}")
+                else:
+                    # Fallback for unknown symbols
+                    logger.warning(f"🔧 SCHEMATIC: Failed to load symbol {comp.lib_id}, using fallback")
+                    lib_symbols[comp.lib_id] = {"definition": "basic"}
+        
+        self._data["lib_symbols"] = lib_symbols
+        
+        # Debug: Log the final lib_symbols structure
+        logger.debug(f"🔧 FINAL: lib_symbols contains {len(lib_symbols)} symbols:")
+        for sym_id in lib_symbols.keys():
+            logger.debug(f"🔧 FINAL: - {sym_id}")
+            # Check if this symbol has extends
+            sym_data = lib_symbols[sym_id]
+            if isinstance(sym_data, list) and len(sym_data) > 2:
+                for item in sym_data[1:]:
+                    if isinstance(item, list) and len(item) >= 2:
+                        if item[0] == sexpdata.Symbol('extends'):
+                            logger.debug(f"🔧 FINAL: - {sym_id} extends {item[1]}")
+                            break
+
+    def _check_symbol_extends(self, symbol_data: Any) -> Optional[str]:
+        """Check if symbol extends another symbol and return parent name."""
+        logger.debug(f"🔧 EXTENDS: Checking symbol data type: {type(symbol_data)}")
+        
+        if not isinstance(symbol_data, list):
+            logger.debug(f"🔧 EXTENDS: Not a list, returning None")
+            return None
+        
+        logger.debug(f"🔧 EXTENDS: Checking {len(symbol_data)} items for extends directive")
+        
+        for i, item in enumerate(symbol_data[1:], 1):
+            logger.debug(f"🔧 EXTENDS: Item {i}: {type(item)} - {item if not isinstance(item, list) else f'list[{len(item)}]'}")
+            if isinstance(item, list) and len(item) >= 2:
+                if item[0] == sexpdata.Symbol('extends'):
+                    parent_name = str(item[1]).strip('"')
+                    logger.debug(f"🔧 EXTENDS: Found extends directive: {parent_name}")
+                    return parent_name
+        
+        logger.debug(f"🔧 EXTENDS: No extends directive found")
+        return None
+
+    def _sync_wires_to_data(self):
+        """Sync wire collection state back to data structure."""
+        wire_data = []
+        for wire in self._wires:
+            wire_dict = {
+                "uuid": wire.uuid,
+                "points": [{"x": p.x, "y": p.y} for p in wire.points],
+                "wire_type": wire.wire_type.value,
+                "stroke_width": wire.stroke_width,
+                "stroke_type": wire.stroke_type
+            }
+            wire_data.append(wire_dict)
+        
+        self._data["wires"] = wire_data
+
+    def _sync_junctions_to_data(self):
+        """Sync junction collection state back to data structure."""
+        junction_data = []
+        for junction in self._junctions:
+            junction_dict = {
+                "uuid": junction.uuid,
+                "position": {"x": junction.position.x, "y": junction.position.y},
+                "diameter": junction.diameter,
+                "color": junction.color
+            }
+            junction_data.append(junction_dict)
+        
+        self._data["junctions"] = junction_data
+
+    def _convert_symbol_to_kicad_format(self, symbol: "SymbolDefinition", lib_id: str) -> Dict[str, Any]:
+        """Convert SymbolDefinition to KiCAD lib_symbols format using raw parsed data."""
+        # If we have raw KiCAD data from the library file, use it directly
+        if hasattr(symbol, 'raw_kicad_data') and symbol.raw_kicad_data:
+            return self._convert_raw_symbol_data(symbol.raw_kicad_data, lib_id)
+        
+        # Fallback: create basic symbol structure  
+        return {
+            "pin_numbers": {"hide": "yes"},
+            "pin_names": {"offset": 0},
+            "exclude_from_sim": "no",
+            "in_bom": "yes", 
+            "on_board": "yes",
+            "properties": {
+                "Reference": {
+                    "value": symbol.reference_prefix,
+                    "at": [2.032, 0, 90],
+                    "effects": {"font": {"size": [1.27, 1.27]}}
+                },
+                "Value": {
+                    "value": symbol.reference_prefix,
+                    "at": [0, 0, 90],
+                    "effects": {"font": {"size": [1.27, 1.27]}}
+                },
+                "Footprint": {
+                    "value": "",
+                    "at": [-1.778, 0, 90],
+                    "effects": {
+                        "font": {"size": [1.27, 1.27]},
+                        "hide": "yes"
+                    }
+                },
+                "Datasheet": {
+                    "value": getattr(symbol, 'Datasheet', None) or getattr(symbol, 'datasheet', None) or "~",
+                    "at": [0, 0, 0],
+                    "effects": {
+                        "font": {"size": [1.27, 1.27]},
+                        "hide": "yes"
+                    }
+                },
+                "Description": {
+                    "value": getattr(symbol, 'Description', None) or getattr(symbol, 'description', None) or "Resistor",
+                    "at": [0, 0, 0],
+                    "effects": {
+                        "font": {"size": [1.27, 1.27]},
+                        "hide": "yes"
+                    }
+                }
+            },
+            "embedded_fonts": "no"
+        }
+
+    def _convert_raw_symbol_data(self, raw_data: List, lib_id: str) -> Dict[str, Any]:
+        """Convert raw parsed KiCAD symbol data to dictionary format for S-expression generation."""
+        import copy
+        import sexpdata
+        
+        # Make a copy and fix symbol name and string/symbol issues
+        modified_data = copy.deepcopy(raw_data)
+        
+        # Replace the symbol name with the full lib_id
+        if len(modified_data) >= 2:
+            modified_data[1] = lib_id  # Change 'R' to 'Device:R'
+        
+        # Fix extends directive to use full lib_id
+        logger.debug(f"🔧 CONVERT: Processing {len(modified_data)} items for {lib_id}")
+        for i, item in enumerate(modified_data[1:], 1):
+            if isinstance(item, list) and len(item) >= 2:
+                logger.debug(f"🔧 CONVERT: Item {i}: {item[0]} = {item[1] if len(item) > 1 else 'N/A'}")
+                if item[0] == sexpdata.Symbol('extends'):
+                    # Convert bare symbol name to full lib_id
+                    parent_name = str(item[1]).strip('"')
+                    parent_lib_id = f"{lib_id.split(':')[0]}:{parent_name}"
+                    modified_data[i][1] = parent_lib_id
+                    logger.debug(f"🔧 CONVERT: Fixed extends directive: {parent_name} -> {parent_lib_id}")
+                    break
+        
+        # Fix string/symbol conversion issues in pin definitions
+        print(f"🔧 DEBUG: Before fix - checking for pin definitions...")
+        self._fix_symbol_strings_recursively(modified_data)
+        print(f"🔧 DEBUG: After fix - symbol strings fixed")
+        
+        return modified_data
+
+    def _fix_symbol_strings_recursively(self, data):
+        """Recursively fix string/symbol issues in parsed S-expression data."""
+        import sexpdata
+        
+        if isinstance(data, list):
+            for i, item in enumerate(data):
+                if isinstance(item, list):
+                    # Check for pin definitions that need fixing
+                    if (len(item) >= 3 and 
+                        item[0] == sexpdata.Symbol('pin')):
+                        print(f"🔧 DEBUG: Found pin definition: {item[:3]} - types: {[type(x) for x in item[:3]]}")
+                        # Fix pin type and shape - ensure they are symbols not strings
+                        if isinstance(item[1], str):
+                            print(f"🔧 DEBUG: Converting pin type '{item[1]}' to symbol")
+                            item[1] = sexpdata.Symbol(item[1])  # pin type: "passive" -> passive
+                        if len(item) >= 3 and isinstance(item[2], str):
+                            print(f"🔧 DEBUG: Converting pin shape '{item[2]}' to symbol")
+                            item[2] = sexpdata.Symbol(item[2])  # pin shape: "line" -> line
+                    
+                    # Recursively process nested lists
+                    self._fix_symbol_strings_recursively(item)
+                elif isinstance(item, str):
+                    # Fix common KiCAD keywords that should be symbols
+                    if item in ['yes', 'no', 'default', 'none', 'left', 'right', 'center']:
+                        data[i] = sexpdata.Symbol(item)
+        
+        return data
 
     @staticmethod
     def _create_empty_schematic_data() -> Dict[str, Any]:
         """Create empty schematic data structure."""
         return {
-            "version": "20230121",
-            "generator": "kicad-sch-api",
+            "version": "20250114",
+            "generator": "eeschema",
+            "generator_version": "9.0",
             "uuid": str(uuid.uuid4()),
+            "paper": "A4",
             "title_block": {
                 "title": "Untitled",
                 "date": "",
@@ -411,6 +1134,14 @@ class Schematic:
             "labels": [],
             "nets": [],
             "lib_symbols": {},
+            "sheet_instances": [
+                {
+                    "path": "/",
+                    "page": "1"
+                }
+            ],
+            "symbol_instances": [],
+            "embedded_fonts": "no",
         }
 
     # Context manager support for atomic operations