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

kicad_sch_api/parsers/elements/label_parser.py

@@ -0,0 +1,216 @@
+"""
+Label and hierarchical label elements parser for KiCAD schematics.
+
+Handles parsing and serialization of Label and hierarchical label 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 LabelParser(BaseElementParser):
+    """Parser for Label and hierarchical label elements."""
+
+    def __init__(self):
+        """Initialize label parser."""
+        super().__init__("label")
+
+    def _parse_label(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a label definition."""
+        # Label format: (label "text" (at x y rotation) (effects ...) (uuid ...))
+        if len(item) < 2:
+            return None
+
+        label_data = {
+            "text": str(item[1]),  # Label text is second element
+            "position": {"x": 0, "y": 0},
+            "rotation": 0,
+            "size": config.defaults.font_size,
+            "justify_h": "left",
+            "justify_v": "bottom",
+            "uuid": None,
+        }
+
+        for elem in item[2:]:  # Skip label keyword and text
+            if not isinstance(elem, list):
+                continue
+
+            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
+
+            if elem_type == "at":
+                # Parse position: (at x y rotation)
+                if len(elem) >= 3:
+                    label_data["position"] = {"x": float(elem[1]), "y": float(elem[2])}
+                if len(elem) >= 4:
+                    label_data["rotation"] = float(elem[3])
+
+            elif elem_type == "effects":
+                # Parse effects for font size and justification: (effects (font (size x y)) (justify left bottom))
+                for effect_elem in elem[1:]:
+                    if isinstance(effect_elem, list):
+                        effect_type = (
+                            str(effect_elem[0])
+                            if isinstance(effect_elem[0], sexpdata.Symbol)
+                            else None
+                        )
+
+                        if effect_type == "font":
+                            # Parse font size
+                            for font_elem in effect_elem[1:]:
+                                if isinstance(font_elem, list) and str(font_elem[0]) == "size":
+                                    if len(font_elem) >= 2:
+                                        label_data["size"] = float(font_elem[1])
+
+                        elif effect_type == "justify":
+                            # Parse justification (e.g., "left bottom", "right top")
+                            # Format: (justify left bottom) or (justify right)
+                            if len(effect_elem) >= 2:
+                                label_data["justify_h"] = str(effect_elem[1])
+                            if len(effect_elem) >= 3:
+                                label_data["justify_v"] = str(effect_elem[2])
+
+            elif elem_type == "uuid":
+                label_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
+
+        return label_data
+
+
+    def _parse_hierarchical_label(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a hierarchical label definition."""
+        # Format: (hierarchical_label "text" (shape input) (at x y rotation) (effects ...) (uuid ...))
+        if len(item) < 2:
+            return None
+
+        hlabel_data = {
+            "text": str(item[1]),  # Hierarchical label text is second element
+            "shape": "input",  # input/output/bidirectional/tri_state/passive
+            "position": {"x": 0, "y": 0},
+            "rotation": 0,
+            "size": config.defaults.font_size,
+            "justify": "left",
+            "uuid": None,
+        }
+
+        for elem in item[2:]:  # Skip hierarchical_label keyword and text
+            if not isinstance(elem, list):
+                continue
+
+            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
+
+            if elem_type == "shape":
+                # Parse shape: (shape input)
+                if len(elem) >= 2:
+                    hlabel_data["shape"] = str(elem[1])
+
+            elif elem_type == "at":
+                # Parse position: (at x y rotation)
+                if len(elem) >= 3:
+                    hlabel_data["position"] = {"x": float(elem[1]), "y": float(elem[2])}
+                if len(elem) >= 4:
+                    hlabel_data["rotation"] = float(elem[3])
+
+            elif elem_type == "effects":
+                # Parse effects for font size and justification: (effects (font (size x y)) (justify left))
+                for effect_elem in elem[1:]:
+                    if isinstance(effect_elem, list):
+                        effect_type = (
+                            str(effect_elem[0])
+                            if isinstance(effect_elem[0], sexpdata.Symbol)
+                            else None
+                        )
+
+                        if effect_type == "font":
+                            # Parse font size
+                            for font_elem in effect_elem[1:]:
+                                if isinstance(font_elem, list) and str(font_elem[0]) == "size":
+                                    if len(font_elem) >= 2:
+                                        hlabel_data["size"] = float(font_elem[1])
+
+                        elif effect_type == "justify":
+                            # Parse justification (e.g., "left", "right")
+                            if len(effect_elem) >= 2:
+                                hlabel_data["justify"] = str(effect_elem[1])
+
+            elif elem_type == "uuid":
+                hlabel_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
+
+        return hlabel_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 and justification)
+        size = label_data.get("size", config.defaults.font_size)
+        effects = [sexpdata.Symbol("effects")]
+        font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), size, size]]
+        effects.append(font)
+
+        # Use justification from data, defaulting to "left bottom"
+        justify_h = label_data.get("justify_h", "left")
+        justify_v = label_data.get("justify_v", "bottom")
+        effects.append(
+            [sexpdata.Symbol("justify"), sexpdata.Symbol(justify_h), sexpdata.Symbol(justify_v)]
+        )
+        sexp.append(effects)
+
+        # Add UUID
+        if "uuid" in label_data:
+            sexp.append([sexpdata.Symbol("uuid"), label_data["uuid"]])
+
+        return sexp
+
+
+    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", config.defaults.font_size)
+        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
+
+

kicad_sch_api/parsers/elements/library_parser.py

@@ -0,0 +1,165 @@
+"""
+Symbol library definitions parser for KiCAD schematics.
+
+Handles parsing and serialization of Symbol library definitions.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import sexpdata
+
+from ..base import BaseElementParser
+
+logger = logging.getLogger(__name__)
+
+
+class LibraryParser(BaseElementParser):
+    """Parser for Symbol library definitions."""
+
+    def __init__(self):
+        """Initialize library parser."""
+        super().__init__("library")
+
+    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
+
+    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
+
+
+    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
+
+

kicad_sch_api/parsers/elements/metadata_parser.py

@@ -0,0 +1,58 @@
+"""
+Title block and symbol instances parser for KiCAD schematics.
+
+Handles parsing and serialization of Title block and symbol instances.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import sexpdata
+
+from ..base import BaseElementParser
+
+logger = logging.getLogger(__name__)
+
+
+class MetadataParser(BaseElementParser):
+    """Parser for Title block and symbol instances."""
+
+    def __init__(self):
+        """Initialize metadata parser."""
+        super().__init__("metadata")
+
+    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
+
+
+    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 []
+
+
+    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
+
+