kicad-sch-api 0.3.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

kicad_sch_api/core/parser.py

@@ -12,6 +12,15 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 import sexpdata
 
+from ..parsers.elements.graphics_parser import GraphicsParser
+from ..parsers.elements.label_parser import LabelParser
+from ..parsers.elements.library_parser import LibraryParser
+from ..parsers.elements.metadata_parser import MetadataParser
+from ..parsers.elements.sheet_parser import SheetParser
+from ..parsers.elements.symbol_parser import SymbolParser
+from ..parsers.elements.text_parser import TextParser
+from ..parsers.elements.wire_parser import WireParser
+from ..parsers.utils import color_to_rgb255, color_to_rgba
 from ..utils.validation import ValidationError, ValidationIssue
 from .formatter import ExactFormatter
 from .types import Junction, Label, Net, Point, SchematicSymbol, Wire
@@ -40,8 +49,30 @@ class SExpressionParser:
         self.preserve_format = preserve_format
         self._formatter = ExactFormatter() if preserve_format else None
         self._validation_issues = []
+        self._graphics_parser = GraphicsParser()
+        self._wire_parser = WireParser()
+        self._label_parser = LabelParser()
+        self._text_parser = TextParser()
+        self._sheet_parser = SheetParser()
+        self._library_parser = LibraryParser()
+        self._symbol_parser = SymbolParser()
+        self._metadata_parser = MetadataParser()
+        self._project_name = None
         logger.info(f"S-expression parser initialized (format preservation: {preserve_format})")
 
+    @property
+    def project_name(self):
+        """Get project name."""
+        return self._project_name
+
+    @project_name.setter
+    def project_name(self, value):
+        """Set project name on parser and propagate to sub-parsers."""
+        self._project_name = value
+        # Propagate to symbol parser which needs it for instances
+        if hasattr(self, '_symbol_parser'):
+            self._symbol_parser.project_name = value
+
     def parse_file(self, filepath: Union[str, Path]) -> Dict[str, Any]:
         """
         Parse a KiCAD schematic file with comprehensive validation.
@@ -187,7 +218,17 @@ class SExpressionParser:
             "wires": [],
             "junctions": [],
             "labels": [],
+            "hierarchical_labels": [],
+            "no_connects": [],
+            "texts": [],
+            "text_boxes": [],
+            "sheets": [],
+            "polylines": [],
+            "arcs": [],
+            "circles": [],
+            "beziers": [],
             "rectangles": [],
+            "images": [],
             "nets": [],
             "lib_symbols": {},
             "sheet_instances": [],
@@ -233,10 +274,50 @@ class SExpressionParser:
                 label = self._parse_label(item)
                 if label:
                     schematic_data["labels"].append(label)
+            elif element_type == "hierarchical_label":
+                hlabel = self._parse_hierarchical_label(item)
+                if hlabel:
+                    schematic_data["hierarchical_labels"].append(hlabel)
+            elif element_type == "no_connect":
+                no_connect = self._parse_no_connect(item)
+                if no_connect:
+                    schematic_data["no_connects"].append(no_connect)
+            elif element_type == "text":
+                text = self._parse_text(item)
+                if text:
+                    schematic_data["texts"].append(text)
+            elif element_type == "text_box":
+                text_box = self._parse_text_box(item)
+                if text_box:
+                    schematic_data["text_boxes"].append(text_box)
+            elif element_type == "sheet":
+                sheet = self._parse_sheet(item)
+                if sheet:
+                    schematic_data["sheets"].append(sheet)
+            elif element_type == "polyline":
+                polyline = self._parse_polyline(item)
+                if polyline:
+                    schematic_data["polylines"].append(polyline)
+            elif element_type == "arc":
+                arc = self._parse_arc(item)
+                if arc:
+                    schematic_data["arcs"].append(arc)
+            elif element_type == "circle":
+                circle = self._parse_circle(item)
+                if circle:
+                    schematic_data["circles"].append(circle)
+            elif element_type == "bezier":
+                bezier = self._parse_bezier(item)
+                if bezier:
+                    schematic_data["beziers"].append(bezier)
             elif element_type == "rectangle":
                 rectangle = self._parse_rectangle(item)
                 if rectangle:
                     schematic_data["rectangles"].append(rectangle)
+            elif element_type == "image":
+                image = self._parse_image(item)
+                if image:
+                    schematic_data["images"].append(image)
             elif element_type == "lib_symbols":
                 schematic_data["lib_symbols"] = self._parse_lib_symbols(item)
             elif element_type == "sheet_instances":
@@ -297,25 +378,48 @@ class SExpressionParser:
         for hlabel in schematic_data.get("hierarchical_labels", []):
             sexp_data.append(self._hierarchical_label_to_sexp(hlabel))
 
-        # Add hierarchical sheets
-        for sheet in schematic_data.get("sheets", []):
-            sexp_data.append(self._sheet_to_sexp(sheet, schematic_data.get("uuid")))
+        # Add no_connects
+        for no_connect in schematic_data.get("no_connects", []):
+            sexp_data.append(self._no_connect_to_sexp(no_connect))
+
+        # Add graphical elements (in KiCad element order)
+        # Beziers
+        for bezier in schematic_data.get("beziers", []):
+            sexp_data.append(self._bezier_to_sexp(bezier))
+
+        # Rectangles (both from API and graphics)
+        for rectangle in schematic_data.get("rectangles", []):
+            sexp_data.append(self._rectangle_to_sexp(rectangle))
+        for graphic in schematic_data.get("graphics", []):
+            sexp_data.append(self._graphic_to_sexp(graphic))
 
-        # Add text elements
+        # Images
+        for image in schematic_data.get("images", []):
+            sexp_data.append(self._image_to_sexp(image))
+
+        # Circles
+        for circle in schematic_data.get("circles", []):
+            sexp_data.append(self._circle_to_sexp(circle))
+
+        # Arcs
+        for arc in schematic_data.get("arcs", []):
+            sexp_data.append(self._arc_to_sexp(arc))
+
+        # Polylines
+        for polyline in schematic_data.get("polylines", []):
+            sexp_data.append(self._polyline_to_sexp(polyline))
+
+        # Text elements
         for text in schematic_data.get("texts", []):
             sexp_data.append(self._text_to_sexp(text))
 
-        # Add text boxes
+        # Text boxes
         for text_box in schematic_data.get("text_boxes", []):
             sexp_data.append(self._text_box_to_sexp(text_box))
 
-        # Add graphics (rectangles from schematic.draw_bounding_box)
-        for graphic in schematic_data.get("graphics", []):
-            sexp_data.append(self._graphic_to_sexp(graphic))
-
-        # Add rectangles (rectangles from add_rectangle API)
-        for rectangle in schematic_data.get("rectangles", []):
-            sexp_data.append(self._rectangle_to_sexp(rectangle))
+        # Hierarchical sheets
+        for sheet in schematic_data.get("sheets", []):
+            sexp_data.append(self._sheet_to_sexp(sheet, schematic_data.get("uuid")))
 
         # Add sheet_instances (required by KiCAD)
         sheet_instances = schematic_data.get("sheet_instances", [])
@@ -339,276 +443,67 @@ class SExpressionParser:
 
     def _parse_title_block(self, item: List[Any]) -> Dict[str, Any]:
         """Parse title block information."""
-        title_block = {}
-        for sub_item in item[1:]:
-            if isinstance(sub_item, list) and len(sub_item) >= 2:
-                key = str(sub_item[0]) if isinstance(sub_item[0], sexpdata.Symbol) else None
-                if key:
-                    title_block[key] = sub_item[1] if len(sub_item) > 1 else None
-        return title_block
-
+        return self._metadata_parser._parse_title_block(item)
     def _parse_symbol(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a symbol (component) definition."""
-        try:
-            symbol_data = {
-                "lib_id": None,
-                "position": Point(0, 0),
-                "rotation": 0,
-                "uuid": None,
-                "reference": None,
-                "value": None,
-                "footprint": None,
-                "properties": {},
-                "pins": [],
-                "in_bom": True,
-                "on_board": True,
-            }
-
-            for sub_item in item[1:]:
-                if not isinstance(sub_item, list) or len(sub_item) == 0:
-                    continue
-
-                element_type = (
-                    str(sub_item[0]) if isinstance(sub_item[0], sexpdata.Symbol) else None
-                )
-
-                if element_type == "lib_id":
-                    symbol_data["lib_id"] = sub_item[1] if len(sub_item) > 1 else None
-                elif element_type == "at":
-                    if len(sub_item) >= 3:
-                        symbol_data["position"] = Point(float(sub_item[1]), float(sub_item[2]))
-                        if len(sub_item) > 3:
-                            symbol_data["rotation"] = float(sub_item[3])
-                elif element_type == "uuid":
-                    symbol_data["uuid"] = sub_item[1] if len(sub_item) > 1 else None
-                elif element_type == "property":
-                    prop_data = self._parse_property(sub_item)
-                    if prop_data:
-                        prop_name = prop_data.get("name")
-                        if prop_name == "Reference":
-                            symbol_data["reference"] = prop_data.get("value")
-                        elif prop_name == "Value":
-                            symbol_data["value"] = prop_data.get("value")
-                        elif prop_name == "Footprint":
-                            symbol_data["footprint"] = prop_data.get("value")
-                        else:
-                            # Unescape quotes in property values when loading
-                            prop_value = prop_data.get("value")
-                            if prop_value:
-                                prop_value = str(prop_value).replace('\\"', '"')
-                            symbol_data["properties"][prop_name] = prop_value
-                elif element_type == "in_bom":
-                    symbol_data["in_bom"] = sub_item[1] == "yes" if len(sub_item) > 1 else True
-                elif element_type == "on_board":
-                    symbol_data["on_board"] = sub_item[1] == "yes" if len(sub_item) > 1 else True
-
-            return symbol_data
-
-        except Exception as e:
-            logger.warning(f"Error parsing symbol: {e}")
-            return None
-
+        return self._symbol_parser._parse_symbol(item)
     def _parse_property(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a property definition."""
-        if len(item) < 3:
-            return None
-
-        return {
-            "name": item[1] if len(item) > 1 else None,
-            "value": item[2] if len(item) > 2 else None,
-        }
-
+        return self._symbol_parser._parse_property(item)
     def _parse_wire(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a wire definition."""
-        # Implementation for wire parsing
-        # This would parse pts, stroke, uuid elements
-        return {}
-
+        return self._wire_parser._parse_wire(item)
     def _parse_junction(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a junction definition."""
-        # Implementation for junction parsing
-        return {}
-
+        return self._wire_parser._parse_junction(item)
     def _parse_label(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a label definition."""
-        # Implementation for label parsing
-        return {}
-
+        return self._label_parser._parse_label(item)
+    def _parse_hierarchical_label(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a hierarchical label definition."""
+        return self._label_parser._parse_hierarchical_label(item)
+    def _parse_no_connect(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a no_connect symbol."""
+        return self._wire_parser._parse_no_connect(item)
+    def _parse_text(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a text element."""
+        return self._text_parser._parse_text(item)
+    def _parse_text_box(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a text_box element."""
+        return self._text_parser._parse_text_box(item)
+    def _parse_sheet(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a hierarchical sheet."""
+        return self._sheet_parser._parse_sheet(item)
+    def _parse_sheet_pin_for_read(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a sheet pin (for reading during sheet parsing)."""
+        return self._sheet_parser._parse_sheet_pin_for_read(item)
+    def _parse_polyline(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a polyline graphical element."""
+        return self._graphics_parser._parse_polyline(item)
+    def _parse_arc(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse an arc graphical element."""
+        return self._graphics_parser._parse_arc(item)
+    def _parse_circle(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a circle graphical element."""
+        return self._graphics_parser._parse_circle(item)
+    def _parse_bezier(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a bezier curve graphical element."""
+        return self._graphics_parser._parse_bezier(item)
     def _parse_rectangle(self, item: List[Any]) -> Optional[Dict[str, Any]]:
         """Parse a rectangle graphical element."""
-        rectangle = {}
-
-        for elem in item[1:]:
-            if not isinstance(elem, list):
-                continue
-
-            elem_type = str(elem[0])
-
-            if elem_type == "start" and len(elem) >= 3:
-                rectangle["start"] = {"x": float(elem[1]), "y": float(elem[2])}
-            elif elem_type == "end" and len(elem) >= 3:
-                rectangle["end"] = {"x": float(elem[1]), "y": float(elem[2])}
-            elif elem_type == "stroke":
-                for stroke_elem in elem[1:]:
-                    if isinstance(stroke_elem, list):
-                        stroke_type = str(stroke_elem[0])
-                        if stroke_type == "width" and len(stroke_elem) >= 2:
-                            rectangle["stroke_width"] = float(stroke_elem[1])
-                        elif stroke_type == "type" and len(stroke_elem) >= 2:
-                            rectangle["stroke_type"] = str(stroke_elem[1])
-            elif elem_type == "fill":
-                for fill_elem in elem[1:]:
-                    if isinstance(fill_elem, list) and str(fill_elem[0]) == "type":
-                        rectangle["fill_type"] = str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
-            elif elem_type == "uuid" and len(elem) >= 2:
-                rectangle["uuid"] = str(elem[1])
-
-        return rectangle if rectangle else None
-
+        return self._graphics_parser._parse_rectangle(item)
+    def _parse_image(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse an image element."""
+        return self._graphics_parser._parse_image(item)
     def _parse_lib_symbols(self, item: List[Any]) -> Dict[str, Any]:
         """Parse lib_symbols section."""
-        # Implementation for lib_symbols parsing
-        return {}
-
-    # Conversion methods from internal format to S-expression
+        return self._library_parser._parse_lib_symbols(item)
     def _title_block_to_sexp(self, title_block: Dict[str, Any]) -> List[Any]:
         """Convert title block to S-expression."""
-        sexp = [sexpdata.Symbol("title_block")]
-
-        # Add standard fields
-        for key in ["title", "date", "rev", "company"]:
-            if key in title_block and title_block[key]:
-                sexp.append([sexpdata.Symbol(key), title_block[key]])
-
-        # Add comments with special formatting
-        comments = title_block.get("comments", {})
-        if isinstance(comments, dict):
-            for comment_num, comment_text in comments.items():
-                sexp.append([sexpdata.Symbol("comment"), comment_num, comment_text])
-
-        return sexp
-
+        return self._metadata_parser._title_block_to_sexp(title_block)
     def _symbol_to_sexp(self, symbol_data: Dict[str, Any], schematic_uuid: str = None) -> List[Any]:
         """Convert symbol to S-expression."""
-        sexp = [sexpdata.Symbol("symbol")]
-
-        if symbol_data.get("lib_id"):
-            sexp.append([sexpdata.Symbol("lib_id"), symbol_data["lib_id"]])
-
-        # Add position and rotation (preserve original format)
-        pos = symbol_data.get("position", Point(0, 0))
-        rotation = symbol_data.get("rotation", 0)
-        # Format numbers as integers if they are whole numbers
-        x = int(pos.x) if pos.x == int(pos.x) else pos.x
-        y = int(pos.y) if pos.y == int(pos.y) else pos.y
-        r = int(rotation) if rotation == int(rotation) else rotation
-        # Always include rotation for format consistency with KiCAD
-        sexp.append([sexpdata.Symbol("at"), x, y, r])
-
-        # Add unit (required by KiCAD)
-        unit = symbol_data.get("unit", 1)
-        sexp.append([sexpdata.Symbol("unit"), unit])
-
-        # Add simulation and board settings (required by KiCAD)
-        sexp.append([sexpdata.Symbol("exclude_from_sim"), "no"])
-        sexp.append([sexpdata.Symbol("in_bom"), "yes" if symbol_data.get("in_bom", True) else "no"])
-        sexp.append(
-            [sexpdata.Symbol("on_board"), "yes" if symbol_data.get("on_board", True) else "no"]
-        )
-        sexp.append([sexpdata.Symbol("dnp"), "no"])
-        sexp.append([sexpdata.Symbol("fields_autoplaced"), "yes"])
-
-        if symbol_data.get("uuid"):
-            sexp.append([sexpdata.Symbol("uuid"), symbol_data["uuid"]])
-
-        # Add properties with proper positioning and effects
-        lib_id = symbol_data.get("lib_id", "")
-        is_power_symbol = "power:" in lib_id
-
-        if symbol_data.get("reference"):
-            # Power symbol references should be hidden by default
-            ref_hide = is_power_symbol
-            ref_prop = self._create_property_with_positioning(
-                "Reference", symbol_data["reference"], pos, 0, "left", hide=ref_hide
-            )
-            sexp.append(ref_prop)
-
-        if symbol_data.get("value"):
-            # Power symbol values need different positioning
-            if is_power_symbol:
-                val_prop = self._create_power_symbol_value_property(
-                    symbol_data["value"], pos, lib_id
-                )
-            else:
-                val_prop = self._create_property_with_positioning(
-                    "Value", symbol_data["value"], pos, 1, "left"
-                )
-            sexp.append(val_prop)
-
-        footprint = symbol_data.get("footprint")
-        if footprint is not None:  # Include empty strings but not None
-            fp_prop = self._create_property_with_positioning(
-                "Footprint", footprint, pos, 2, "left", hide=True
-            )
-            sexp.append(fp_prop)
-
-        for prop_name, prop_value in symbol_data.get("properties", {}).items():
-            escaped_value = str(prop_value).replace('"', '\\"')
-            prop = self._create_property_with_positioning(
-                prop_name, escaped_value, pos, 3, "left", hide=True
-            )
-            sexp.append(prop)
-
-        # Add pin UUID assignments (required by KiCAD)
-        for pin in symbol_data.get("pins", []):
-            pin_uuid = str(uuid.uuid4())
-            # Ensure pin number is a string for proper quoting
-            pin_number = str(pin.number)
-            sexp.append([sexpdata.Symbol("pin"), pin_number, [sexpdata.Symbol("uuid"), pin_uuid]])
-
-        # Add instances section (required by KiCAD)
-        from .config import config
-
-        # Get project name from config or properties
-        project_name = symbol_data.get("properties", {}).get("project_name")
-        if not project_name:
-            project_name = getattr(self, "project_name", config.defaults.project_name)
-
-        # CRITICAL FIX: Use the FULL hierarchy_path from properties if available
-        # For hierarchical schematics, this contains the complete path: /root_uuid/sheet_symbol_uuid/...
-        # This ensures KiCad can properly annotate components in sub-sheets
-        hierarchy_path = symbol_data.get("properties", {}).get("hierarchy_path")
-        if hierarchy_path:
-            # Use the full hierarchical path (includes root + all sheet symbols)
-            instance_path = hierarchy_path
-            logger.debug(f"🔧 Using FULL hierarchy_path: {instance_path} for component {symbol_data.get('reference', 'unknown')}")
-        else:
-            # Fallback: use root_uuid or schematic_uuid for flat designs
-            root_uuid = symbol_data.get("properties", {}).get("root_uuid") or schematic_uuid or str(uuid.uuid4())
-            instance_path = f"/{root_uuid}"
-            logger.debug(f"🔧 Using root UUID path: {instance_path} for component {symbol_data.get('reference', 'unknown')}")
-
-        logger.debug(f"🔧 Component properties keys: {list(symbol_data.get('properties', {}).keys())}")
-        logger.debug(f"🔧 Using project name: '{project_name}'")
-
-        sexp.append(
-            [
-                sexpdata.Symbol("instances"),
-                [
-                    sexpdata.Symbol("project"),
-                    project_name,
-                    [
-                        sexpdata.Symbol("path"),
-                        instance_path,
-                        [sexpdata.Symbol("reference"), symbol_data.get("reference", "U?")],
-                        [sexpdata.Symbol("unit"), symbol_data.get("unit", 1)],
-                    ],
-                ],
-            ]
-        )
-
-        return sexp
-
+        return self._symbol_parser._symbol_to_sexp(symbol_data, schematic_uuid)
     def _create_property_with_positioning(
         self,
         prop_name: str,
@@ -692,745 +587,74 @@ class SExpressionParser:
 
     def _wire_to_sexp(self, wire_data: Dict[str, Any]) -> List[Any]:
         """Convert wire to S-expression."""
-        sexp = [sexpdata.Symbol("wire")]
-
-        # Add points (pts section)
-        points = wire_data.get("points", [])
-        if len(points) >= 2:
-            pts_sexp = [sexpdata.Symbol("pts")]
-            for point in points:
-                if isinstance(point, dict):
-                    x, y = point["x"], point["y"]
-                elif isinstance(point, (list, tuple)) and len(point) >= 2:
-                    x, y = point[0], point[1]
-                else:
-                    # Assume it's a Point object
-                    x, y = point.x, point.y
-
-                # Format coordinates properly (avoid unnecessary .0 for integers)
-                if isinstance(x, float) and x.is_integer():
-                    x = int(x)
-                if isinstance(y, float) and y.is_integer():
-                    y = int(y)
-
-                pts_sexp.append([sexpdata.Symbol("xy"), x, y])
-            sexp.append(pts_sexp)
-
-        # Add stroke information
-        stroke_width = wire_data.get("stroke_width", 0)
-        stroke_type = wire_data.get("stroke_type", "default")
-        stroke_sexp = [sexpdata.Symbol("stroke")]
-
-        # Format stroke width (use int for 0, preserve float for others)
-        if isinstance(stroke_width, float) and stroke_width == 0.0:
-            stroke_width = 0
-
-        stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
-        stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(stroke_type)])
-        sexp.append(stroke_sexp)
-
-        # Add UUID
-        if "uuid" in wire_data:
-            sexp.append([sexpdata.Symbol("uuid"), wire_data["uuid"]])
-
-        return sexp
-
+        return self._wire_parser._wire_to_sexp(wire_data)
     def _junction_to_sexp(self, junction_data: Dict[str, Any]) -> List[Any]:
         """Convert junction to S-expression."""
-        sexp = [sexpdata.Symbol("junction")]
-
-        # Add position
-        pos = junction_data["position"]
-        if isinstance(pos, dict):
-            x, y = pos["x"], pos["y"]
-        elif isinstance(pos, (list, tuple)) and len(pos) >= 2:
-            x, y = pos[0], pos[1]
-        else:
-            # Assume it's a Point object
-            x, y = pos.x, pos.y
-
-        # Format coordinates properly
-        if isinstance(x, float) and x.is_integer():
-            x = int(x)
-        if isinstance(y, float) and y.is_integer():
-            y = int(y)
-
-        sexp.append([sexpdata.Symbol("at"), x, y])
-
-        # Add diameter
-        diameter = junction_data.get("diameter", 0)
-        sexp.append([sexpdata.Symbol("diameter"), diameter])
-
-        # Add color (RGBA)
-        color = junction_data.get("color", (0, 0, 0, 0))
-        if isinstance(color, (list, tuple)) and len(color) >= 4:
-            sexp.append([sexpdata.Symbol("color"), color[0], color[1], color[2], color[3]])
-        else:
-            sexp.append([sexpdata.Symbol("color"), 0, 0, 0, 0])
-
-        # Add UUID
-        if "uuid" in junction_data:
-            sexp.append([sexpdata.Symbol("uuid"), junction_data["uuid"]])
-
-        return sexp
-
+        return self._wire_parser._junction_to_sexp(junction_data)
     def _label_to_sexp(self, label_data: Dict[str, Any]) -> List[Any]:
         """Convert local label to S-expression."""
-        sexp = [sexpdata.Symbol("label"), label_data["text"]]
-
-        # Add position
-        pos = label_data["position"]
-        x, y = pos["x"], pos["y"]
-        rotation = label_data.get("rotation", 0)
-
-        # Format coordinates properly
-        if isinstance(x, float) and x.is_integer():
-            x = int(x)
-        if isinstance(y, float) and y.is_integer():
-            y = int(y)
-
-        sexp.append([sexpdata.Symbol("at"), x, y, rotation])
-
-        # Add effects (font properties)
-        size = label_data.get("size", 1.27)
-        effects = [sexpdata.Symbol("effects")]
-        font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), size, size]]
-        effects.append(font)
-        effects.append(
-            [sexpdata.Symbol("justify"), sexpdata.Symbol("left"), sexpdata.Symbol("bottom")]
-        )
-        sexp.append(effects)
-
-        # Add UUID
-        if "uuid" in label_data:
-            sexp.append([sexpdata.Symbol("uuid"), label_data["uuid"]])
-
-        return sexp
-
+        return self._label_parser._label_to_sexp(label_data)
     def _hierarchical_label_to_sexp(self, hlabel_data: Dict[str, Any]) -> List[Any]:
         """Convert hierarchical label to S-expression."""
-        sexp = [sexpdata.Symbol("hierarchical_label"), hlabel_data["text"]]
-
-        # Add shape
-        shape = hlabel_data.get("shape", "input")
-        sexp.append([sexpdata.Symbol("shape"), sexpdata.Symbol(shape)])
-
-        # Add position
-        pos = hlabel_data["position"]
-        x, y = pos["x"], pos["y"]
-        rotation = hlabel_data.get("rotation", 0)
-        sexp.append([sexpdata.Symbol("at"), x, y, rotation])
-
-        # Add effects (font properties)
-        size = hlabel_data.get("size", 1.27)
-        effects = [sexpdata.Symbol("effects")]
-        font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), size, size]]
-        effects.append(font)
-
-        # Use justification from data if provided, otherwise default to "left"
-        justify = hlabel_data.get("justify", "left")
-        effects.append([sexpdata.Symbol("justify"), sexpdata.Symbol(justify)])
-        sexp.append(effects)
-
-        # Add UUID
-        if "uuid" in hlabel_data:
-            sexp.append([sexpdata.Symbol("uuid"), hlabel_data["uuid"]])
-
-        return sexp
-
+        return self._label_parser._hierarchical_label_to_sexp(hlabel_data)
+    def _no_connect_to_sexp(self, no_connect_data: Dict[str, Any]) -> List[Any]:
+        """Convert no_connect to S-expression."""
+        return self._wire_parser._no_connect_to_sexp(no_connect_data)
+    def _polyline_to_sexp(self, polyline_data: Dict[str, Any]) -> List[Any]:
+        """Convert polyline to S-expression."""
+        return self._graphics_parser._polyline_to_sexp(polyline_data)
+    def _arc_to_sexp(self, arc_data: Dict[str, Any]) -> List[Any]:
+        """Convert arc to S-expression."""
+        return self._graphics_parser._arc_to_sexp(arc_data)
+    def _circle_to_sexp(self, circle_data: Dict[str, Any]) -> List[Any]:
+        """Convert circle to S-expression."""
+        return self._graphics_parser._circle_to_sexp(circle_data)
+    def _bezier_to_sexp(self, bezier_data: Dict[str, Any]) -> List[Any]:
+        """Convert bezier curve to S-expression."""
+        return self._graphics_parser._bezier_to_sexp(bezier_data)
     def _sheet_to_sexp(self, sheet_data: Dict[str, Any], schematic_uuid: str) -> List[Any]:
         """Convert hierarchical sheet to S-expression."""
-        sexp = [sexpdata.Symbol("sheet")]
-
-        # Add position
-        pos = sheet_data["position"]
-        x, y = pos["x"], pos["y"]
-        if isinstance(x, float) and x.is_integer():
-            x = int(x)
-        if isinstance(y, float) and y.is_integer():
-            y = int(y)
-        sexp.append([sexpdata.Symbol("at"), x, y])
-
-        # Add size
-        size = sheet_data["size"]
-        w, h = size["width"], size["height"]
-        sexp.append([sexpdata.Symbol("size"), w, h])
-
-        # Add basic properties
-        sexp.append(
-            [
-                sexpdata.Symbol("exclude_from_sim"),
-                sexpdata.Symbol("yes" if sheet_data.get("exclude_from_sim", False) else "no"),
-            ]
-        )
-        sexp.append(
-            [
-                sexpdata.Symbol("in_bom"),
-                sexpdata.Symbol("yes" if sheet_data.get("in_bom", True) else "no"),
-            ]
-        )
-        sexp.append(
-            [
-                sexpdata.Symbol("on_board"),
-                sexpdata.Symbol("yes" if sheet_data.get("on_board", True) else "no"),
-            ]
-        )
-        sexp.append(
-            [
-                sexpdata.Symbol("dnp"),
-                sexpdata.Symbol("yes" if sheet_data.get("dnp", False) else "no"),
-            ]
-        )
-        sexp.append(
-            [
-                sexpdata.Symbol("fields_autoplaced"),
-                sexpdata.Symbol("yes" if sheet_data.get("fields_autoplaced", True) else "no"),
-            ]
-        )
-
-        # Add stroke
-        stroke_width = sheet_data.get("stroke_width", 0.1524)
-        stroke_type = sheet_data.get("stroke_type", "solid")
-        stroke_sexp = [sexpdata.Symbol("stroke")]
-        stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
-        stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(stroke_type)])
-        sexp.append(stroke_sexp)
-
-        # Add fill
-        fill_color = sheet_data.get("fill_color", (0, 0, 0, 0.0))
-        fill_sexp = [sexpdata.Symbol("fill")]
-        fill_sexp.append(
-            [sexpdata.Symbol("color"), fill_color[0], fill_color[1], fill_color[2], fill_color[3]]
-        )
-        sexp.append(fill_sexp)
-
-        # Add UUID
-        if "uuid" in sheet_data:
-            sexp.append([sexpdata.Symbol("uuid"), sheet_data["uuid"]])
-
-        # Add sheet properties (name and filename)
-        name = sheet_data.get("name", "Sheet")
-        filename = sheet_data.get("filename", "sheet.kicad_sch")
-
-        # Sheetname property
-        from .config import config
-
-        name_prop = [sexpdata.Symbol("property"), "Sheetname", name]
-        name_prop.append(
-            [sexpdata.Symbol("at"), x, round(y + config.sheet.name_offset_y, 4), 0]
-        )  # Above sheet
-        name_prop.append(
-            [
-                sexpdata.Symbol("effects"),
-                [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                [sexpdata.Symbol("justify"), sexpdata.Symbol("left"), sexpdata.Symbol("bottom")],
-            ]
-        )
-        sexp.append(name_prop)
-
-        # Sheetfile property
-        file_prop = [sexpdata.Symbol("property"), "Sheetfile", filename]
-        file_prop.append(
-            [sexpdata.Symbol("at"), x, round(y + h + config.sheet.file_offset_y, 4), 0]
-        )  # Below sheet
-        file_prop.append(
-            [
-                sexpdata.Symbol("effects"),
-                [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                [sexpdata.Symbol("justify"), sexpdata.Symbol("left"), sexpdata.Symbol("top")],
-            ]
-        )
-        sexp.append(file_prop)
-
-        # Add sheet pins if any
-        for pin in sheet_data.get("pins", []):
-            pin_sexp = self._sheet_pin_to_sexp(pin)
-            sexp.append(pin_sexp)
-
-        # Add instances
-        if schematic_uuid:
-            instances_sexp = [sexpdata.Symbol("instances")]
-            project_name = sheet_data.get("project_name", "")
-            page_number = sheet_data.get("page_number", "2")
-            project_sexp = [sexpdata.Symbol("project"), project_name]
-            path_sexp = [sexpdata.Symbol("path"), f"/{schematic_uuid}"]
-            path_sexp.append([sexpdata.Symbol("page"), page_number])
-            project_sexp.append(path_sexp)
-            instances_sexp.append(project_sexp)
-            sexp.append(instances_sexp)
-
-        return sexp
-
+        return self._sheet_parser._sheet_to_sexp(sheet_data, schematic_uuid)
     def _sheet_pin_to_sexp(self, pin_data: Dict[str, Any]) -> List[Any]:
         """Convert sheet pin to S-expression."""
-        pin_sexp = [
-            sexpdata.Symbol("pin"),
-            pin_data["name"],
-            sexpdata.Symbol(pin_data.get("pin_type", "input")),
-        ]
-
-        # Add position
-        pos = pin_data["position"]
-        x, y = pos["x"], pos["y"]
-        rotation = pin_data.get("rotation", 0)
-        pin_sexp.append([sexpdata.Symbol("at"), x, y, rotation])
-
-        # Add UUID
-        if "uuid" in pin_data:
-            pin_sexp.append([sexpdata.Symbol("uuid"), pin_data["uuid"]])
-
-        # Add effects
-        size = pin_data.get("size", 1.27)
-        effects = [sexpdata.Symbol("effects")]
-        font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), size, size]]
-        effects.append(font)
-        justify = pin_data.get("justify", "right")
-        effects.append([sexpdata.Symbol("justify"), sexpdata.Symbol(justify)])
-        pin_sexp.append(effects)
-
-        return pin_sexp
-
+        return self._sheet_parser._sheet_pin_to_sexp(pin_data)
     def _text_to_sexp(self, text_data: Dict[str, Any]) -> List[Any]:
         """Convert text element to S-expression."""
-        sexp = [sexpdata.Symbol("text"), text_data["text"]]
-
-        # Add exclude_from_sim
-        exclude_sim = text_data.get("exclude_from_sim", False)
-        sexp.append(
-            [sexpdata.Symbol("exclude_from_sim"), sexpdata.Symbol("yes" if exclude_sim else "no")]
-        )
-
-        # Add position
-        pos = text_data["position"]
-        x, y = pos["x"], pos["y"]
-        rotation = text_data.get("rotation", 0)
-
-        # Format coordinates properly
-        if isinstance(x, float) and x.is_integer():
-            x = int(x)
-        if isinstance(y, float) and y.is_integer():
-            y = int(y)
-
-        sexp.append([sexpdata.Symbol("at"), x, y, rotation])
-
-        # Add effects (font properties)
-        size = text_data.get("size", 1.27)
-        effects = [sexpdata.Symbol("effects")]
-        font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), size, size]]
-        effects.append(font)
-        sexp.append(effects)
-
-        # Add UUID
-        if "uuid" in text_data:
-            sexp.append([sexpdata.Symbol("uuid"), text_data["uuid"]])
-
-        return sexp
-
+        return self._text_parser._text_to_sexp(text_data)
     def _text_box_to_sexp(self, text_box_data: Dict[str, Any]) -> List[Any]:
         """Convert text box element to S-expression."""
-        sexp = [sexpdata.Symbol("text_box"), text_box_data["text"]]
-
-        # Add exclude_from_sim
-        exclude_sim = text_box_data.get("exclude_from_sim", False)
-        sexp.append(
-            [sexpdata.Symbol("exclude_from_sim"), sexpdata.Symbol("yes" if exclude_sim else "no")]
-        )
-
-        # Add position
-        pos = text_box_data["position"]
-        x, y = pos["x"], pos["y"]
-        rotation = text_box_data.get("rotation", 0)
-
-        # Format coordinates properly
-        if isinstance(x, float) and x.is_integer():
-            x = int(x)
-        if isinstance(y, float) and y.is_integer():
-            y = int(y)
-
-        sexp.append([sexpdata.Symbol("at"), x, y, rotation])
-
-        # Add size
-        size = text_box_data["size"]
-        w, h = size["width"], size["height"]
-        sexp.append([sexpdata.Symbol("size"), w, h])
-
-        # Add margins
-        margins = text_box_data.get("margins", (0.9525, 0.9525, 0.9525, 0.9525))
-        sexp.append([sexpdata.Symbol("margins"), margins[0], margins[1], margins[2], margins[3]])
-
-        # Add stroke
-        stroke_width = text_box_data.get("stroke_width", 0)
-        stroke_type = text_box_data.get("stroke_type", "solid")
-        stroke_sexp = [sexpdata.Symbol("stroke")]
-        stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
-        stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(stroke_type)])
-        sexp.append(stroke_sexp)
-
-        # Add fill
-        fill_type = text_box_data.get("fill_type", "none")
-        fill_sexp = [sexpdata.Symbol("fill")]
-        fill_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(fill_type)])
-        sexp.append(fill_sexp)
-
-        # Add effects (font properties and justification)
-        font_size = text_box_data.get("font_size", 1.27)
-        justify_h = text_box_data.get("justify_horizontal", "left")
-        justify_v = text_box_data.get("justify_vertical", "top")
-
-        effects = [sexpdata.Symbol("effects")]
-        font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), font_size, font_size]]
-        effects.append(font)
-        effects.append(
-            [sexpdata.Symbol("justify"), sexpdata.Symbol(justify_h), sexpdata.Symbol(justify_v)]
-        )
-        sexp.append(effects)
-
-        # Add UUID
-        if "uuid" in text_box_data:
-            sexp.append([sexpdata.Symbol("uuid"), text_box_data["uuid"]])
-
-        return sexp
-
+        return self._text_parser._text_box_to_sexp(text_box_data)
     def _rectangle_to_sexp(self, rectangle_data: Dict[str, Any]) -> List[Any]:
         """Convert rectangle element to S-expression."""
-        sexp = [sexpdata.Symbol("rectangle")]
-
-        # Add start point
-        start = rectangle_data["start"]
-        start_x, start_y = start["x"], start["y"]
-        sexp.append([sexpdata.Symbol("start"), start_x, start_y])
-
-        # Add end point
-        end = rectangle_data["end"]
-        end_x, end_y = end["x"], end["y"]
-        sexp.append([sexpdata.Symbol("end"), end_x, end_y])
-
-        # Add stroke
-        stroke_width = rectangle_data.get("stroke_width", 0)
-        stroke_type = rectangle_data.get("stroke_type", "default")
-        stroke_sexp = [sexpdata.Symbol("stroke")]
-        stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
-        stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(stroke_type)])
-        sexp.append(stroke_sexp)
-
-        # Add fill
-        fill_type = rectangle_data.get("fill_type", "none")
-        fill_sexp = [sexpdata.Symbol("fill")]
-        fill_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(fill_type)])
-        sexp.append(fill_sexp)
-
-        # Add UUID
-        if "uuid" in rectangle_data:
-            sexp.append([sexpdata.Symbol("uuid"), rectangle_data["uuid"]])
-
-        return sexp
-
+        return self._graphics_parser._rectangle_to_sexp(rectangle_data)
+    def _image_to_sexp(self, image_data: Dict[str, Any]) -> List[Any]:
+        """Convert image element to S-expression."""
+        return self._graphics_parser._image_to_sexp(image_data)
     def _lib_symbols_to_sexp(self, lib_symbols: Dict[str, Any]) -> List[Any]:
         """Convert lib_symbols to S-expression."""
-        sexp = [sexpdata.Symbol("lib_symbols")]
-
-        # Add each symbol definition
-        for symbol_name, symbol_def in lib_symbols.items():
-            if isinstance(symbol_def, list):
-                # Raw S-expression data from parsed library file - use directly
-                sexp.append(symbol_def)
-            elif isinstance(symbol_def, dict):
-                # Dictionary format - convert to S-expression
-                symbol_sexp = self._create_basic_symbol_definition(symbol_name)
-                sexp.append(symbol_sexp)
-
-        return sexp
-
+        return self._library_parser._lib_symbols_to_sexp(lib_symbols)
     def _create_basic_symbol_definition(self, lib_id: str) -> List[Any]:
         """Create a basic symbol definition for KiCAD compatibility."""
-        symbol_sexp = [sexpdata.Symbol("symbol"), lib_id]
-
-        # Add basic symbol properties
-        symbol_sexp.extend(
-            [
-                [sexpdata.Symbol("pin_numbers"), [sexpdata.Symbol("hide"), sexpdata.Symbol("yes")]],
-                [sexpdata.Symbol("pin_names"), [sexpdata.Symbol("offset"), 0]],
-                [sexpdata.Symbol("exclude_from_sim"), sexpdata.Symbol("no")],
-                [sexpdata.Symbol("in_bom"), sexpdata.Symbol("yes")],
-                [sexpdata.Symbol("on_board"), sexpdata.Symbol("yes")],
-            ]
-        )
-
-        # Add basic properties for the symbol
-        if "R" in lib_id:  # Resistor
-            symbol_sexp.extend(
-                [
-                    [
-                        sexpdata.Symbol("property"),
-                        "Reference",
-                        "R",
-                        [sexpdata.Symbol("at"), 2.032, 0, 90],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                        ],
-                    ],
-                    [
-                        sexpdata.Symbol("property"),
-                        "Value",
-                        "R",
-                        [sexpdata.Symbol("at"), 0, 0, 90],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                        ],
-                    ],
-                    [
-                        sexpdata.Symbol("property"),
-                        "Footprint",
-                        "",
-                        [sexpdata.Symbol("at"), -1.778, 0, 90],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                            [sexpdata.Symbol("hide"), sexpdata.Symbol("yes")],
-                        ],
-                    ],
-                    [
-                        sexpdata.Symbol("property"),
-                        "Datasheet",
-                        "~",
-                        [sexpdata.Symbol("at"), 0, 0, 0],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                            [sexpdata.Symbol("hide"), sexpdata.Symbol("yes")],
-                        ],
-                    ],
-                ]
-            )
-
-        elif "C" in lib_id:  # Capacitor
-            symbol_sexp.extend(
-                [
-                    [
-                        sexpdata.Symbol("property"),
-                        "Reference",
-                        "C",
-                        [sexpdata.Symbol("at"), 0.635, 2.54, 0],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                        ],
-                    ],
-                    [
-                        sexpdata.Symbol("property"),
-                        "Value",
-                        "C",
-                        [sexpdata.Symbol("at"), 0.635, -2.54, 0],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                        ],
-                    ],
-                    [
-                        sexpdata.Symbol("property"),
-                        "Footprint",
-                        "",
-                        [sexpdata.Symbol("at"), 0, -1.27, 0],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                            [sexpdata.Symbol("hide"), sexpdata.Symbol("yes")],
-                        ],
-                    ],
-                    [
-                        sexpdata.Symbol("property"),
-                        "Datasheet",
-                        "~",
-                        [sexpdata.Symbol("at"), 0, 0, 0],
-                        [
-                            sexpdata.Symbol("effects"),
-                            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
-                            [sexpdata.Symbol("hide"), sexpdata.Symbol("yes")],
-                        ],
-                    ],
-                ]
-            )
-
-        # Add basic graphics and pins (minimal for now)
-        symbol_sexp.append([sexpdata.Symbol("embedded_fonts"), sexpdata.Symbol("no")])
-
-        return symbol_sexp
-
+        return self._library_parser._create_basic_symbol_definition(lib_id)
     def _parse_sheet_instances(self, item: List[Any]) -> List[Dict[str, Any]]:
         """Parse sheet_instances section."""
-        sheet_instances = []
-        for sheet_item in item[1:]:  # Skip 'sheet_instances' header
-            if isinstance(sheet_item, list) and len(sheet_item) > 0:
-                sheet_data = {"path": "/", "page": "1"}
-                for element in sheet_item[1:]:  # Skip element header
-                    if isinstance(element, list) and len(element) >= 2:
-                        key = (
-                            str(element[0])
-                            if isinstance(element[0], sexpdata.Symbol)
-                            else str(element[0])
-                        )
-                        if key == "path":
-                            sheet_data["path"] = element[1]
-                        elif key == "page":
-                            sheet_data["page"] = element[1]
-                sheet_instances.append(sheet_data)
-        return sheet_instances
-
+        return self._sheet_parser._parse_sheet_instances(item)
     def _parse_symbol_instances(self, item: List[Any]) -> List[Any]:
         """Parse symbol_instances section."""
-        # For now, just return the raw structure minus the header
-        return item[1:] if len(item) > 1 else []
-
+        return self._metadata_parser._parse_symbol_instances(item)
     def _sheet_instances_to_sexp(self, sheet_instances: List[Dict[str, Any]]) -> List[Any]:
         """Convert sheet_instances to S-expression."""
-        sexp = [sexpdata.Symbol("sheet_instances")]
-        for sheet in sheet_instances:
-            # Create: (path "/" (page "1"))
-            sheet_sexp = [
-                sexpdata.Symbol("path"),
-                sheet.get("path", "/"),
-                [sexpdata.Symbol("page"), str(sheet.get("page", "1"))],
-            ]
-            sexp.append(sheet_sexp)
-        return sexp
-
+        return self._sheet_parser._sheet_instances_to_sexp(sheet_instances)
     def _graphic_to_sexp(self, graphic_data: Dict[str, Any]) -> List[Any]:
         """Convert graphics (rectangles, etc.) to S-expression."""
-        # For now, we only support rectangles - this is the main graphics element we create
-        sexp = [sexpdata.Symbol("rectangle")]
-
-        # Add start position
-        start = graphic_data.get("start", {})
-        start_x = start.get("x", 0)
-        start_y = start.get("y", 0)
-
-        # Format coordinates properly (avoid unnecessary .0 for integers)
-        if isinstance(start_x, float) and start_x.is_integer():
-            start_x = int(start_x)
-        if isinstance(start_y, float) and start_y.is_integer():
-            start_y = int(start_y)
-
-        sexp.append([sexpdata.Symbol("start"), start_x, start_y])
-
-        # Add end position
-        end = graphic_data.get("end", {})
-        end_x = end.get("x", 0)
-        end_y = end.get("y", 0)
-
-        # Format coordinates properly (avoid unnecessary .0 for integers)
-        if isinstance(end_x, float) and end_x.is_integer():
-            end_x = int(end_x)
-        if isinstance(end_y, float) and end_y.is_integer():
-            end_y = int(end_y)
-
-        sexp.append([sexpdata.Symbol("end"), end_x, end_y])
-
-        # Add stroke information (KiCAD format: width, type, and optionally color)
-        stroke = graphic_data.get("stroke", {})
-        stroke_sexp = [sexpdata.Symbol("stroke")]
-
-        # Stroke width - default to 0 to match KiCAD behavior
-        stroke_width = stroke.get("width", 0)
-        if isinstance(stroke_width, float) and stroke_width == 0.0:
-            stroke_width = 0
-        stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
-
-        # Stroke type - normalize to KiCAD format and validate
-        stroke_type = stroke.get("type", "default")
-
-        # KiCAD only supports these exact stroke types
-        valid_kicad_types = {"solid", "dash", "dash_dot", "dash_dot_dot", "dot", "default"}
-
-        # Map common variations to KiCAD format
-        stroke_type_map = {
-            "dashdot": "dash_dot",
-            "dash-dot": "dash_dot",
-            "dashdotdot": "dash_dot_dot",
-            "dash-dot-dot": "dash_dot_dot",
-            "solid": "solid",
-            "dash": "dash",
-            "dot": "dot",
-            "default": "default",
-        }
-
-        # Normalize and validate
-        normalized_stroke_type = stroke_type_map.get(stroke_type.lower(), stroke_type)
-        if normalized_stroke_type not in valid_kicad_types:
-            normalized_stroke_type = "default"  # Fallback to default for invalid types
-
-        stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(normalized_stroke_type)])
-
-        # Stroke color (if specified) - KiCAD format uses RGB 0-255 values plus alpha
-        stroke_color = stroke.get("color")
-        if stroke_color:
-            if isinstance(stroke_color, str):
-                # Convert string color names to RGB 0-255 values
-                color_rgb = self._color_to_rgb255(stroke_color)
-                stroke_sexp.append([sexpdata.Symbol("color")] + color_rgb + [1])  # Add alpha=1
-            elif isinstance(stroke_color, (list, tuple)) and len(stroke_color) >= 3:
-                # Use provided RGB values directly
-                stroke_sexp.append([sexpdata.Symbol("color")] + list(stroke_color))
-
-        sexp.append(stroke_sexp)
-
-        # Add fill information
-        fill = graphic_data.get("fill", {"type": "none"})
-        fill_type = fill.get("type", "none")
-        fill_sexp = [sexpdata.Symbol("fill"), [sexpdata.Symbol("type"), sexpdata.Symbol(fill_type)]]
-        sexp.append(fill_sexp)
-
-        # Add UUID (no quotes around UUID in KiCAD format)
-        if "uuid" in graphic_data:
-            uuid_str = graphic_data["uuid"]
-            # Remove quotes and convert to Symbol to match KiCAD format
-            uuid_clean = uuid_str.replace('"', "")
-            sexp.append([sexpdata.Symbol("uuid"), sexpdata.Symbol(uuid_clean)])
-
-        return sexp
-
+        return self._graphics_parser._graphic_to_sexp(graphic_data)
     def _color_to_rgba(self, color_name: str) -> List[float]:
         """Convert color name to RGBA values (0.0-1.0) for KiCAD compatibility."""
-        # Basic color mapping for common colors (0.0-1.0 range)
-        color_map = {
-            "red": [1.0, 0.0, 0.0, 1.0],
-            "blue": [0.0, 0.0, 1.0, 1.0],
-            "green": [0.0, 1.0, 0.0, 1.0],
-            "yellow": [1.0, 1.0, 0.0, 1.0],
-            "magenta": [1.0, 0.0, 1.0, 1.0],
-            "cyan": [0.0, 1.0, 1.0, 1.0],
-            "black": [0.0, 0.0, 0.0, 1.0],
-            "white": [1.0, 1.0, 1.0, 1.0],
-            "gray": [0.5, 0.5, 0.5, 1.0],
-            "grey": [0.5, 0.5, 0.5, 1.0],
-            "orange": [1.0, 0.5, 0.0, 1.0],
-            "purple": [0.5, 0.0, 0.5, 1.0],
-        }
-
-        # Return RGBA values, default to black if color not found
-        return color_map.get(color_name.lower(), [0.0, 0.0, 0.0, 1.0])
+        return color_to_rgba(color_name)
 
     def _color_to_rgb255(self, color_name: str) -> List[int]:
         """Convert color name to RGB values (0-255) for KiCAD rectangle graphics."""
-        # Basic color mapping for common colors (0-255 range)
-        color_map = {
-            "red": [255, 0, 0],
-            "blue": [0, 0, 255],
-            "green": [0, 255, 0],
-            "yellow": [255, 255, 0],
-            "magenta": [255, 0, 255],
-            "cyan": [0, 255, 255],
-            "black": [0, 0, 0],
-            "white": [255, 255, 255],
-            "gray": [128, 128, 128],
-            "grey": [128, 128, 128],
-            "orange": [255, 128, 0],
-            "purple": [128, 0, 128],
-        }
-
-        # Return RGB values, default to black if color not found
-        return color_map.get(color_name.lower(), [0, 0, 0])
+        return color_to_rgb255(color_name)
 
     def get_validation_issues(self) -> List[ValidationIssue]:
         """Get list of validation issues from last parse operation."""