kicad-sch-api 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

kicad_sch_api/parsers/elements/sheet_parser.py

@@ -0,0 +1,352 @@
+"""
+Hierarchical sheet elements parser for KiCAD schematics.
+
+Handles parsing and serialization of Hierarchical sheet elements.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import sexpdata
+
+from ...core.config import config
+from ..base import BaseElementParser
+
+logger = logging.getLogger(__name__)
+
+
+class SheetParser(BaseElementParser):
+    """Parser for Hierarchical sheet elements."""
+
+    def __init__(self):
+        """Initialize sheet parser."""
+        super().__init__("sheet")
+
+    def _parse_sheet(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a hierarchical sheet."""
+        # Complex format with position, size, properties, pins, instances
+        sheet_data = {
+            "position": {"x": 0, "y": 0},
+            "size": {"width": 0, "height": 0},
+            "exclude_from_sim": False,
+            "in_bom": True,
+            "on_board": True,
+            "dnp": False,
+            "fields_autoplaced": True,
+            "stroke_width": 0.1524,
+            "stroke_type": "solid",
+            "fill_color": (0, 0, 0, 0.0),
+            "uuid": None,
+            "name": "Sheet",
+            "filename": "sheet.kicad_sch",
+            "pins": [],
+            "project_name": "",
+            "page_number": "2",
+        }
+
+        for elem in item[1:]:
+            if not isinstance(elem, list):
+                continue
+
+            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
+
+            if elem_type == "at":
+                if len(elem) >= 3:
+                    sheet_data["position"] = {"x": float(elem[1]), "y": float(elem[2])}
+            elif elem_type == "size":
+                if len(elem) >= 3:
+                    sheet_data["size"] = {"width": float(elem[1]), "height": float(elem[2])}
+            elif elem_type == "exclude_from_sim":
+                sheet_data["exclude_from_sim"] = str(elem[1]) == "yes" if len(elem) > 1 else False
+            elif elem_type == "in_bom":
+                sheet_data["in_bom"] = str(elem[1]) == "yes" if len(elem) > 1 else True
+            elif elem_type == "on_board":
+                sheet_data["on_board"] = str(elem[1]) == "yes" if len(elem) > 1 else True
+            elif elem_type == "dnp":
+                sheet_data["dnp"] = str(elem[1]) == "yes" if len(elem) > 1 else False
+            elif elem_type == "fields_autoplaced":
+                sheet_data["fields_autoplaced"] = str(elem[1]) == "yes" if len(elem) > 1 else True
+            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:
+                            sheet_data["stroke_width"] = float(stroke_elem[1])
+                        elif stroke_type == "type" and len(stroke_elem) >= 2:
+                            sheet_data["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]) == "color":
+                        if len(fill_elem) >= 5:
+                            sheet_data["fill_color"] = (
+                                int(fill_elem[1]),
+                                int(fill_elem[2]),
+                                int(fill_elem[3]),
+                                float(fill_elem[4]),
+                            )
+            elif elem_type == "uuid":
+                sheet_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
+            elif elem_type == "property":
+                if len(elem) >= 3:
+                    prop_name = str(elem[1])
+                    prop_value = str(elem[2])
+                    if prop_name == "Sheetname":
+                        sheet_data["name"] = prop_value
+                    elif prop_name == "Sheetfile":
+                        sheet_data["filename"] = prop_value
+            elif elem_type == "pin":
+                # Parse sheet pin - reuse existing _parse_sheet_pin helper
+                pin_data = self._parse_sheet_pin_for_read(elem)
+                if pin_data:
+                    sheet_data["pins"].append(pin_data)
+            elif elem_type == "instances":
+                # Parse instances for project name and page number
+                for inst_elem in elem[1:]:
+                    if isinstance(inst_elem, list) and str(inst_elem[0]) == "project":
+                        if len(inst_elem) >= 2:
+                            sheet_data["project_name"] = str(inst_elem[1])
+                        for path_elem in inst_elem[2:]:
+                            if isinstance(path_elem, list) and str(path_elem[0]) == "path":
+                                for page_elem in path_elem[1:]:
+                                    if isinstance(page_elem, list) and str(page_elem[0]) == "page":
+                                        sheet_data["page_number"] = (
+                                            str(page_elem[1]) if len(page_elem) > 1 else "2"
+                                        )
+
+        return sheet_data
+
+
+    def _parse_sheet_pin_for_read(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a sheet pin (for reading during sheet parsing)."""
+        # Format: (pin "name" type (at x y rotation) (uuid ...) (effects ...))
+        if len(item) < 3:
+            return None
+
+        pin_data = {
+            "name": str(item[1]),
+            "pin_type": str(item[2]) if len(item) > 2 else "input",
+            "position": {"x": 0, "y": 0},
+            "rotation": 0,
+            "size": config.defaults.font_size,
+            "justify": "right",
+            "uuid": None,
+        }
+
+        for elem in item[3:]:
+            if not isinstance(elem, list):
+                continue
+
+            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
+
+            if elem_type == "at":
+                if len(elem) >= 3:
+                    pin_data["position"] = {"x": float(elem[1]), "y": float(elem[2])}
+                if len(elem) >= 4:
+                    pin_data["rotation"] = float(elem[3])
+            elif elem_type == "uuid":
+                pin_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
+            elif elem_type == "effects":
+                for effect_elem in elem[1:]:
+                    if isinstance(effect_elem, list):
+                        effect_type = str(effect_elem[0])
+                        if effect_type == "font":
+                            for font_elem in effect_elem[1:]:
+                                if isinstance(font_elem, list) and str(font_elem[0]) == "size":
+                                    if len(font_elem) >= 2:
+                                        pin_data["size"] = float(font_elem[1])
+                        elif effect_type == "justify":
+                            if len(effect_elem) >= 2:
+                                pin_data["justify"] = str(effect_elem[1])
+
+        return pin_data
+
+
+    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
+
+
+    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 ...core.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"), config.defaults.font_size, config.defaults.font_size]],
+                [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"), config.defaults.font_size, config.defaults.font_size]],
+                [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
+
+
+    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", config.defaults.font_size)
+        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
+
+
+    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
+
+

kicad_sch_api/parsers/elements/symbol_parser.py

@@ -0,0 +1,313 @@
+"""
+Component symbol elements parser for KiCAD schematics.
+
+Handles parsing and serialization of Component symbol elements.
+"""
+
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+import sexpdata
+
+from ...core.types import Point
+from ..base import BaseElementParser
+
+logger = logging.getLogger(__name__)
+
+
+class SymbolParser(BaseElementParser):
+    """Parser for Component symbol elements."""
+
+    def __init__(self):
+        """Initialize symbol parser."""
+        super().__init__("symbol")
+
+    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
+
+
+    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,
+        }
+
+
+    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 ...core.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
+
+
+    def _create_property_with_positioning(
+        self,
+        prop_name: str,
+        prop_value: str,
+        component_pos: Point,
+        offset_index: int,
+        justify: str = "left",
+        hide: bool = False,
+    ) -> List[Any]:
+        """Create a property with proper positioning and effects like KiCAD."""
+        from ...core.config import config
+
+        # Calculate property position using configuration
+        prop_x, prop_y, rotation = config.get_property_position(
+            prop_name, (component_pos.x, component_pos.y), offset_index
+        )
+
+        # Build effects section based on hide status
+        effects = [
+            sexpdata.Symbol("effects"),
+            [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
+        ]
+
+        # Only add justify for visible properties or Reference/Value
+        if not hide or prop_name in ["Reference", "Value"]:
+            effects.append([sexpdata.Symbol("justify"), sexpdata.Symbol(justify)])
+
+        if hide:
+            effects.append([sexpdata.Symbol("hide"), sexpdata.Symbol("yes")])
+
+        prop_sexp = [
+            sexpdata.Symbol("property"),
+            prop_name,
+            prop_value,
+            [
+                sexpdata.Symbol("at"),
+                round(prop_x, 4) if prop_x != int(prop_x) else int(prop_x),
+                round(prop_y, 4) if prop_y != int(prop_y) else int(prop_y),
+                rotation,
+            ],
+            effects,
+        ]
+
+        return prop_sexp
+
+
+    def _create_power_symbol_value_property(
+        self, value: str, component_pos: Point, lib_id: str
+    ) -> List[Any]:
+        """Create Value property for power symbols with correct positioning."""
+        # Power symbols have different value positioning based on type
+        if "GND" in lib_id:
+            # GND value goes below the symbol
+            prop_x = component_pos.x
+            prop_y = component_pos.y + 5.08  # Below GND symbol
+        elif "+3.3V" in lib_id or "VDD" in lib_id:
+            # Positive voltage values go below the symbol
+            prop_x = component_pos.x
+            prop_y = component_pos.y - 5.08  # Above symbol (negative offset)
+        else:
+            # Default power symbol positioning
+            prop_x = component_pos.x
+            prop_y = component_pos.y + 3.556
+
+        prop_sexp = [
+            sexpdata.Symbol("property"),
+            "Value",
+            value,
+            [
+                sexpdata.Symbol("at"),
+                round(prop_x, 4) if prop_x != int(prop_x) else int(prop_x),
+                round(prop_y, 4) if prop_y != int(prop_y) else int(prop_y),
+                0,
+            ],
+            [
+                sexpdata.Symbol("effects"),
+                [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), 1.27, 1.27]],
+            ],
+        ]
+
+        return prop_sexp
+
+