kicad-sch-api 0.3.5__py3-none-any.whl → 0.4.1__py3-none-any.whl

kicad_sch_api/parsers/symbol_parser.py

@@ -1,227 +0,0 @@
-"""
-Symbol element parser for S-expression symbol definitions.
-
-Handles parsing of symbol elements with properties, positions, and library references.
-"""
-
-import logging
-from typing import Any, Dict, List, Optional
-
-import sexpdata
-
-from .base import BaseElementParser
-
-logger = logging.getLogger(__name__)
-
-
-class SymbolParser(BaseElementParser):
-    """Parser for symbol S-expression elements."""
-
-    def __init__(self):
-        """Initialize symbol parser."""
-        super().__init__("symbol")
-
-    def parse_element(self, element: List[Any]) -> Optional[Dict[str, Any]]:
-        """
-        Parse a symbol S-expression element.
-
-        Expected format:
-        (symbol (lib_id "Device:R") (at x y angle) (property "Reference" "R1" ...)...)
-
-        Args:
-            element: Symbol S-expression element
-
-        Returns:
-            Parsed symbol data with library ID, position, and properties
-        """
-        symbol_data = {
-            "lib_id": "",
-            "position": {"x": 0, "y": 0, "angle": 0},
-            "mirror": "",
-            "unit": 1,
-            "in_bom": True,
-            "on_board": True,
-            "fields_autoplaced": False,
-            "uuid": None,
-            "properties": [],
-            "instances": []
-        }
-
-        for elem in element[1:]:
-            if not isinstance(elem, list):
-                continue
-
-            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
-
-            if elem_type == "lib_id":
-                symbol_data["lib_id"] = str(elem[1]) if len(elem) > 1 else ""
-            elif elem_type == "at":
-                self._parse_position(elem, symbol_data)
-            elif elem_type == "mirror":
-                symbol_data["mirror"] = str(elem[1]) if len(elem) > 1 else ""
-            elif elem_type == "unit":
-                symbol_data["unit"] = int(elem[1]) if len(elem) > 1 else 1
-            elif elem_type == "in_bom":
-                symbol_data["in_bom"] = self._parse_boolean(elem[1]) if len(elem) > 1 else True
-            elif elem_type == "on_board":
-                symbol_data["on_board"] = self._parse_boolean(elem[1]) if len(elem) > 1 else True
-            elif elem_type == "fields_autoplaced":
-                symbol_data["fields_autoplaced"] = True
-            elif elem_type == "uuid":
-                symbol_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
-            elif elem_type == "property":
-                prop = self._parse_property(elem)
-                if prop:
-                    symbol_data["properties"].append(prop)
-            elif elem_type == "instances":
-                symbol_data["instances"] = self._parse_instances(elem)
-
-        return symbol_data
-
-    def _parse_position(self, at_element: List[Any], symbol_data: Dict[str, Any]) -> None:
-        """
-        Parse position from at element.
-
-        Args:
-            at_element: (at x y [angle])
-            symbol_data: Symbol data dictionary to update
-        """
-        try:
-            if len(at_element) >= 3:
-                symbol_data["position"]["x"] = float(at_element[1])
-                symbol_data["position"]["y"] = float(at_element[2])
-            if len(at_element) >= 4:
-                symbol_data["position"]["angle"] = float(at_element[3])
-        except (ValueError, IndexError) as e:
-            self._logger.warning(f"Invalid position coordinates: {at_element}, error: {e}")
-
-    def _parse_property(self, prop_element: List[Any]) -> Optional[Dict[str, Any]]:
-        """
-        Parse a property element.
-
-        Args:
-            prop_element: (property "name" "value" (at x y angle) ...)
-
-        Returns:
-            Parsed property data or None if invalid
-        """
-        if len(prop_element) < 3:
-            return None
-
-        prop_data = {
-            "name": str(prop_element[1]),
-            "value": str(prop_element[2]),
-            "position": {"x": 0, "y": 0, "angle": 0},
-            "effects": {}
-        }
-
-        # Parse additional property elements
-        for elem in prop_element[3:]:
-            if isinstance(elem, list) and len(elem) > 0:
-                elem_type = str(elem[0])
-                if elem_type == "at":
-                    self._parse_property_position(elem, prop_data)
-                elif elem_type == "effects":
-                    prop_data["effects"] = self._parse_effects(elem)
-
-        return prop_data
-
-    def _parse_property_position(self, at_element: List[Any], prop_data: Dict[str, Any]) -> None:
-        """Parse property position from at element."""
-        try:
-            if len(at_element) >= 3:
-                prop_data["position"]["x"] = float(at_element[1])
-                prop_data["position"]["y"] = float(at_element[2])
-            if len(at_element) >= 4:
-                prop_data["position"]["angle"] = float(at_element[3])
-        except (ValueError, IndexError) as e:
-            self._logger.warning(f"Invalid property position: {at_element}, error: {e}")
-
-    def _parse_effects(self, effects_element: List[Any]) -> Dict[str, Any]:
-        """Parse effects element for text formatting."""
-        effects = {
-            "font_size": 1.27,
-            "font_thickness": 0.15,
-            "bold": False,
-            "italic": False,
-            "hide": False,
-            "justify": []
-        }
-
-        for elem in effects_element[1:]:
-            if isinstance(elem, list) and len(elem) > 0:
-                elem_type = str(elem[0])
-                if elem_type == "font":
-                    self._parse_font(elem, effects)
-                elif elem_type == "justify":
-                    effects["justify"] = [str(j) for j in elem[1:]]
-                elif elem_type == "hide":
-                    effects["hide"] = True
-
-        return effects
-
-    def _parse_font(self, font_element: List[Any], effects: Dict[str, Any]) -> None:
-        """Parse font element within effects."""
-        for elem in font_element[1:]:
-            if isinstance(elem, list) and len(elem) > 0:
-                elem_type = str(elem[0])
-                if elem_type == "size":
-                    try:
-                        if len(elem) >= 3:
-                            effects["font_size"] = float(elem[1])
-                    except (ValueError, IndexError):
-                        pass
-                elif elem_type == "thickness":
-                    try:
-                        effects["font_thickness"] = float(elem[1])
-                    except (ValueError, IndexError):
-                        pass
-                elif elem_type == "bold":
-                    effects["bold"] = True
-                elif elem_type == "italic":
-                    effects["italic"] = True
-
-    def _parse_instances(self, instances_element: List[Any]) -> List[Dict[str, Any]]:
-        """Parse instances element for symbol instances."""
-        instances = []
-        for elem in instances_element[1:]:
-            if isinstance(elem, list) and len(elem) > 0 and str(elem[0]) == "instance":
-                instance = self._parse_instance(elem)
-                if instance:
-                    instances.append(instance)
-        return instances
-
-    def _parse_instance(self, instance_element: List[Any]) -> Optional[Dict[str, Any]]:
-        """Parse a single instance element."""
-        instance = {
-            "project": "",
-            "path": "",
-            "reference": "",
-            "unit": 1
-        }
-
-        for elem in instance_element[1:]:
-            if isinstance(elem, list) and len(elem) >= 2:
-                elem_type = str(elem[0])
-                if elem_type == "project":
-                    instance["project"] = str(elem[1])
-                elif elem_type == "path":
-                    instance["path"] = str(elem[1])
-                elif elem_type == "reference":
-                    instance["reference"] = str(elem[1])
-                elif elem_type == "unit":
-                    try:
-                        instance["unit"] = int(elem[1])
-                    except (ValueError, IndexError):
-                        pass
-
-        return instance if instance["reference"] else None
-
-    def _parse_boolean(self, value: Any) -> bool:
-        """Parse boolean value from S-expression."""
-        if isinstance(value, str):
-            return value.lower() in ("yes", "true", "1")
-        elif isinstance(value, sexpdata.Symbol):
-            return str(value).lower() in ("yes", "true", "1")
-        else:
-            return bool(value)

kicad_sch_api/parsers/wire_parser.py

@@ -1,99 +0,0 @@
-"""
-Wire element parser for S-expression wire definitions.
-
-Handles parsing of wire elements with points, stroke properties, and UUIDs.
-"""
-
-import logging
-from typing import Any, Dict, List, Optional
-
-import sexpdata
-
-from .base import BaseElementParser
-
-logger = logging.getLogger(__name__)
-
-
-class WireParser(BaseElementParser):
-    """Parser for wire S-expression elements."""
-
-    def __init__(self):
-        """Initialize wire parser."""
-        super().__init__("wire")
-
-    def parse_element(self, element: List[Any]) -> Optional[Dict[str, Any]]:
-        """
-        Parse a wire S-expression element.
-
-        Expected format:
-        (wire (pts (xy x1 y1) (xy x2 y2) ...) (stroke (width w) (type t)) (uuid "..."))
-
-        Args:
-            element: Wire S-expression element
-
-        Returns:
-            Parsed wire data with points, stroke, and UUID information
-        """
-        wire_data = {
-            "points": [],
-            "stroke_width": 0.0,
-            "stroke_type": "default",
-            "uuid": None,
-            "wire_type": "wire"  # Default to wire (vs bus)
-        }
-
-        for elem in element[1:]:
-            if not isinstance(elem, list):
-                continue
-
-            elem_type = str(elem[0]) if isinstance(elem[0], sexpdata.Symbol) else None
-
-            if elem_type == "pts":
-                self._parse_points(elem, wire_data)
-            elif elem_type == "stroke":
-                self._parse_stroke(elem, wire_data)
-            elif elem_type == "uuid":
-                wire_data["uuid"] = str(elem[1]) if len(elem) > 1 else None
-
-        # Validate wire has sufficient points
-        if len(wire_data["points"]) >= 2:
-            return wire_data
-        else:
-            self._logger.warning(f"Wire has insufficient points: {len(wire_data['points'])}")
-            return None
-
-    def _parse_points(self, pts_element: List[Any], wire_data: Dict[str, Any]) -> None:
-        """
-        Parse points from pts element.
-
-        Args:
-            pts_element: (pts (xy x1 y1) (xy x2 y2) ...)
-            wire_data: Wire data dictionary to update
-        """
-        for pt in pts_element[1:]:
-            if isinstance(pt, list) and len(pt) >= 3:
-                if str(pt[0]) == "xy":
-                    try:
-                        x, y = float(pt[1]), float(pt[2])
-                        wire_data["points"].append({"x": x, "y": y})
-                    except (ValueError, IndexError) as e:
-                        self._logger.warning(f"Invalid point coordinates: {pt}, error: {e}")
-
-    def _parse_stroke(self, stroke_element: List[Any], wire_data: Dict[str, Any]) -> None:
-        """
-        Parse stroke properties from stroke element.
-
-        Args:
-            stroke_element: (stroke (width w) (type t))
-            wire_data: Wire data dictionary to update
-        """
-        for stroke_elem in stroke_element[1:]:
-            if isinstance(stroke_elem, list) and len(stroke_elem) >= 2:
-                stroke_type = str(stroke_elem[0])
-                try:
-                    if stroke_type == "width":
-                        wire_data["stroke_width"] = float(stroke_elem[1])
-                    elif stroke_type == "type":
-                        wire_data["stroke_type"] = str(stroke_elem[1])
-                except (ValueError, IndexError) as e:
-                    self._logger.warning(f"Invalid stroke property: {stroke_elem}, error: {e}")

kicad_sch_api-0.3.5.dist-info/RECORD

@@ -1,58 +0,0 @@
-kicad_sch_api/__init__.py,sha256=87qLx-VMQTBHDVq_CiXW-6wyKtvLFc3AsKQaoLKsIbs,2919
-kicad_sch_api/cli.py,sha256=ZzmwzfHEvPgGfCiQBU4G2LBAyRtMNiBRoY21pivJSYc,7621
-kicad_sch_api/py.typed,sha256=e4ldqxwpY7pNDG1olbvj4HSKr8sZ9vxgA_2ek8xXn-Q,70
-kicad_sch_api/collections/__init__.py,sha256=VqVucNyFa6E86TX6z0EmJirjFU2scinMdOlIIzHzljc,626
-kicad_sch_api/collections/base.py,sha256=b1U7gIFOP0YEajUXc499aOoCBGm6UUsWUUj3-DiI0gs,8417
-kicad_sch_api/collections/components.py,sha256=7SKTVWnWvzqDkFtLemYd7iC1MaKjB7dpqmPjtNQVIxQ,13888
-kicad_sch_api/collections/junctions.py,sha256=pSNWNDe4TZ8C1t0jC0BcMP3kzx15g4LaHBJwSrETsgU,11770
-kicad_sch_api/collections/labels.py,sha256=dGmlSOHON5YA0C1CfjT-mMutg10FGB4j5eyikA3LGT4,12314
-kicad_sch_api/collections/wires.py,sha256=OkCxvkljrq3AdjQD9iRpIsMqx3-RRPhnlOvoZaaFpd8,12375
-kicad_sch_api/core/__init__.py,sha256=ur_KeYBlGKl-e1hLpLdxAhGV2A-PCCGkcqd0r6KSeBA,566
-kicad_sch_api/core/component_bounds.py,sha256=BFYJYULyzs5it2hN7bHTimyS9Vet4dxsMklRStob-F4,17509
-kicad_sch_api/core/components.py,sha256=tXRL18GObl2u94wl5jP-1ID56s_UD9F1gQ_iRIyZ_Kw,25290
-kicad_sch_api/core/config.py,sha256=itw0j3DeIEHaFVf8p3mfAS1SP6jclBwvMv7NPdkThE4,4309
-kicad_sch_api/core/formatter.py,sha256=zzZi0f06C1YWUy5l0WFS9G4KRTEzmAY3rFK3XGocvCo,22185
-kicad_sch_api/core/geometry.py,sha256=27SgN0padLbQuTi8MV6UUCp6Pyaiv8V9gmYDOhfwny8,2947
-kicad_sch_api/core/ic_manager.py,sha256=Kg0HIOMU-TGXiIkrnwcHFQ1Kfv_3rW2U1cwBKJsKopc,7219
-kicad_sch_api/core/junctions.py,sha256=Ay6BsWX_DLs-wB0eMA2CytKKq0N8Ja41ZubJWpAqNgM,6122
-kicad_sch_api/core/labels.py,sha256=jOg2NSCkD7CvOwOubezzCDFMM7NM4kXoxBkcSZQrUio,11093
-kicad_sch_api/core/manhattan_routing.py,sha256=t_T2u0zsQB-a8dTijFmY-qFq-oDt2qDebYyXzD_pBWI,15989
-kicad_sch_api/core/nets.py,sha256=0kaYvRylAwP7XDuhTsONA-QuLu141C3Q9Cyu0plds94,9587
-kicad_sch_api/core/no_connects.py,sha256=kyvIkLuN4bizqacKb_a80kQvQ3HOpdCDcxIxby15dQE,9411
-kicad_sch_api/core/parser.py,sha256=UY_GNX1yHd3xgTVqZ9TZe1u94q4YZBo-NibsSH8Jy44,94983
-kicad_sch_api/core/pin_utils.py,sha256=XGEow3HzBTyT8a0B_ZC8foMvwzYaENSaqTUwDW1rz24,5417
-kicad_sch_api/core/schematic.py,sha256=Y1EnWifc_xjI9bHsHW3gwgQWwOrhRCXkIRKSomTBfA4,67496
-kicad_sch_api/core/simple_manhattan.py,sha256=CvIHvwmfABPF-COzhblYxEgRoR_R_eD-lmBFHHjDuMI,7241
-kicad_sch_api/core/texts.py,sha256=NUKoqldVI771w6aTCCNssuqyOLFGFSsRduD8iewBFQA,10726
-kicad_sch_api/core/types.py,sha256=DfXbIdw76nZZCQlat30wNzmec7oBUWnjHoWHjmo32Qc,14174
-kicad_sch_api/core/wire_routing.py,sha256=G-C7S-ntQxwuu1z3OaaYlkURXwKE4r4xmhbbi6cvvaI,12830
-kicad_sch_api/core/wires.py,sha256=608t9oH4UzppdGgNgUd-ABK6T-ahyETZwhO_-CuKFO8,8319
-kicad_sch_api/discovery/__init__.py,sha256=qSuCsnC-hVtaLYE8fwd-Gea6JKwEVGPQ-hSNDNJYsIU,329
-kicad_sch_api/discovery/search_index.py,sha256=KgQT8ipT9OU6ktUwhDZ37Mao0Cba0fJOsxUk9m8ZKbY,15856
-kicad_sch_api/geometry/__init__.py,sha256=hTBXkn8mZZCjzDIrtPv67QsnCYB77L67JjthQgEIX7o,716
-kicad_sch_api/geometry/font_metrics.py,sha256=qqnfBuRqiLQDnGkk64rKzdyvuSNU0uBfdp0TKEgzXds,831
-kicad_sch_api/geometry/symbol_bbox.py,sha256=ewd1HmGNae68zlxYnF2JMCvvjf53p1f6mXlpl0ixQq4,23902
-kicad_sch_api/interfaces/__init__.py,sha256=X85PQ2-ic4796xuTSUxnZP8iiliVzGTM2nCAylicTMw,434
-kicad_sch_api/interfaces/parser.py,sha256=y06cJsJ_OB2SgYZeqaix77j1m_pND3N0bBQVTvIl7gI,2007
-kicad_sch_api/interfaces/repository.py,sha256=qN-jCymSFIgGgWTBWrFGSrLNVXuFRr1mPXvpNmLrXH0,1762
-kicad_sch_api/interfaces/resolver.py,sha256=St1mCvRem661Bt1H_gPiWQxIaD1edkFEoNfn41Txmoo,2935
-kicad_sch_api/library/__init__.py,sha256=NG9UTdcpn25Bl9tPsYs9ED7bvpaVPVdtLMbnxkQkOnU,250
-kicad_sch_api/library/cache.py,sha256=7na88grl465WHwUOGuOzYrrWwjsMBXhXVtxhnaJ9GBY,33208
-kicad_sch_api/parsers/__init__.py,sha256=8GwbDcj1iJnGjcqXEwqqbRbIBr163_SqdntY6CP1K-g,356
-kicad_sch_api/parsers/base.py,sha256=P4MPkowJibbrGWoZ2fvpgx5ZS9vQ4FsiJqXTBRx3WX0,4633
-kicad_sch_api/parsers/label_parser.py,sha256=K9xxh_ZHvVFf4C51KvdSwR-WtmNsS0PSCQ6zrkbUpXg,8685
-kicad_sch_api/parsers/registry.py,sha256=J1i5WQY-AS5jGxYKvcTNW01c368VV4VeGCmh-6ye89w,5067
-kicad_sch_api/parsers/symbol_parser.py,sha256=FWGSYYKWBInXv9v8EsqFbuapfs-K4jf6PQFvbWkK9eU,8465
-kicad_sch_api/parsers/wire_parser.py,sha256=AEVc8Z-qghTGKSY1CFGEnjXeBX7dDVENQxvLsBFzxqI,3418
-kicad_sch_api/symbols/__init__.py,sha256=VXZeUUHajFtXexFw6ZrLPxL231JN4Z9ZOchYZSHkrH0,500
-kicad_sch_api/symbols/cache.py,sha256=UOy8r02eWtBtbovcYNs-cWUYKhkaAzQHPmOLm_0tcBw,16221
-kicad_sch_api/symbols/resolver.py,sha256=CsvCzEzXa869IzJoD0k_BsRj_bAATJo4O4WO48IyuYs,12090
-kicad_sch_api/symbols/validators.py,sha256=Uu5VueSexLDPElx1nen7KuOs250tXEwYedHid7a5WsM,15836
-kicad_sch_api/utils/__init__.py,sha256=1V_yGgI7jro6MUc4Pviux_WIeJ1wmiYFID186SZwWLQ,277
-kicad_sch_api/utils/validation.py,sha256=XlWGRZJb3cOPYpU9sLQQgC_NASwbi6W-LCN7PzUmaPY,15626
-kicad_sch_api-0.3.5.dist-info/licenses/LICENSE,sha256=Em65Nvte1G9MHc0rHqtYuGkCPcshD588itTa358J6gs,1070
-kicad_sch_api-0.3.5.dist-info/METADATA,sha256=uxxdX5QZHo_K2VohvK4cWFDO8G0hEV03uRoo8Wt2hd8,17183
-kicad_sch_api-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kicad_sch_api-0.3.5.dist-info/entry_points.txt,sha256=VWKsFi2Jv7G_tmio3cNVhhIBfv_OZFaKa-T_ED84lc8,57
-kicad_sch_api-0.3.5.dist-info/top_level.txt,sha256=n0ex4gOJ1b_fARowcGqRzyOGZcHRhc5LZa6_vVgGxcI,14
-kicad_sch_api-0.3.5.dist-info/RECORD,,