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

kicad_sch_api/core/schematic.py

@@ -17,6 +17,7 @@ import sexpdata
 from ..library.cache import get_symbol_cache
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
 from .components import ComponentCollection
+from .factories import ElementFactory
 from .formatter import ExactFormatter
 from .junctions import JunctionCollection
 from .labels import LabelCollection
@@ -49,6 +50,7 @@ from .types import (
     TitleBlock,
     Wire,
     WireType,
+    point_from_dict_or_tuple,
 )
 from .wires import WireCollection
 
@@ -107,105 +109,22 @@ class Schematic:
 
         # Initialize wire collection
         wire_data = self._data.get("wires", [])
-        wires = []
-        for wire_dict in wire_data:
-            if isinstance(wire_dict, dict):
-                # Convert dict to Wire object
-                points = []
-                for point_data in wire_dict.get("points", []):
-                    if isinstance(point_data, dict):
-                        points.append(Point(point_data["x"], point_data["y"]))
-                    elif isinstance(point_data, (list, tuple)):
-                        points.append(Point(point_data[0], point_data[1]))
-                    else:
-                        points.append(point_data)
-
-                wire = Wire(
-                    uuid=wire_dict.get("uuid", str(uuid.uuid4())),
-                    points=points,
-                    wire_type=WireType(wire_dict.get("wire_type", "wire")),
-                    stroke_width=wire_dict.get("stroke_width", 0.0),
-                    stroke_type=wire_dict.get("stroke_type", "default"),
-                )
-                wires.append(wire)
+        wires = ElementFactory.create_wires_from_list(wire_data)
         self._wires = WireCollection(wires)
 
         # Initialize junction collection
         junction_data = self._data.get("junctions", [])
-        junctions = []
-        for junction_dict in junction_data:
-            if isinstance(junction_dict, dict):
-                # Convert dict to Junction object
-                position = junction_dict.get("position", {"x": 0, "y": 0})
-                if isinstance(position, dict):
-                    pos = Point(position["x"], position["y"])
-                elif isinstance(position, (list, tuple)):
-                    pos = Point(position[0], position[1])
-                else:
-                    pos = position
-
-                junction = Junction(
-                    uuid=junction_dict.get("uuid", str(uuid.uuid4())),
-                    position=pos,
-                    diameter=junction_dict.get("diameter", 0),
-                    color=junction_dict.get("color", (0, 0, 0, 0)),
-                )
-                junctions.append(junction)
+        junctions = ElementFactory.create_junctions_from_list(junction_data)
         self._junctions = JunctionCollection(junctions)
 
         # Initialize text collection
         text_data = self._data.get("texts", [])
-        texts = []
-        for text_dict in text_data:
-            if isinstance(text_dict, dict):
-                # Convert dict to Text object
-                position = text_dict.get("position", {"x": 0, "y": 0})
-                if isinstance(position, dict):
-                    pos = Point(position["x"], position["y"])
-                elif isinstance(position, (list, tuple)):
-                    pos = Point(position[0], position[1])
-                else:
-                    pos = position
-
-                text = Text(
-                    uuid=text_dict.get("uuid", str(uuid.uuid4())),
-                    position=pos,
-                    text=text_dict.get("text", ""),
-                    rotation=text_dict.get("rotation", 0.0),
-                    size=text_dict.get("size", 1.27),
-                    exclude_from_sim=text_dict.get("exclude_from_sim", False),
-                )
-                texts.append(text)
+        texts = ElementFactory.create_texts_from_list(text_data)
         self._texts = TextCollection(texts)
 
         # Initialize label collection
         label_data = self._data.get("labels", [])
-        labels = []
-        for label_dict in label_data:
-            if isinstance(label_dict, dict):
-                # Convert dict to Label object
-                position = label_dict.get("position", {"x": 0, "y": 0})
-                if isinstance(position, dict):
-                    pos = Point(position["x"], position["y"])
-                elif isinstance(position, (list, tuple)):
-                    pos = Point(position[0], position[1])
-                else:
-                    pos = position
-
-                label = Label(
-                    uuid=label_dict.get("uuid", str(uuid.uuid4())),
-                    position=pos,
-                    text=label_dict.get("text", ""),
-                    label_type=LabelType(label_dict.get("label_type", "local")),
-                    rotation=label_dict.get("rotation", 0.0),
-                    size=label_dict.get("size", 1.27),
-                    shape=(
-                        HierarchicalLabelShape(label_dict.get("shape"))
-                        if label_dict.get("shape")
-                        else None
-                    ),
-                )
-                labels.append(label)
+        labels = ElementFactory.create_labels_from_list(label_data)
         self._labels = LabelCollection(labels)
 
         # Initialize hierarchical labels collection (from both labels array and hierarchical_labels array)
@@ -215,68 +134,18 @@ class Schematic:
 
         # Also load from hierarchical_labels data if present
         hierarchical_label_data = self._data.get("hierarchical_labels", [])
-        for hlabel_dict in hierarchical_label_data:
-            if isinstance(hlabel_dict, dict):
-                # Convert dict to Label object
-                position = hlabel_dict.get("position", {"x": 0, "y": 0})
-                if isinstance(position, dict):
-                    pos = Point(position["x"], position["y"])
-                elif isinstance(position, (list, tuple)):
-                    pos = Point(position[0], position[1])
-                else:
-                    pos = position
-
-                hlabel = Label(
-                    uuid=hlabel_dict.get("uuid", str(uuid.uuid4())),
-                    position=pos,
-                    text=hlabel_dict.get("text", ""),
-                    label_type=LabelType.HIERARCHICAL,
-                    rotation=hlabel_dict.get("rotation", 0.0),
-                    size=hlabel_dict.get("size", 1.27),
-                    shape=(
-                        HierarchicalLabelShape(hlabel_dict.get("shape"))
-                        if hlabel_dict.get("shape")
-                        else None
-                    ),
-                )
-                hierarchical_labels.append(hlabel)
+        hierarchical_labels.extend(ElementFactory.create_labels_from_list(hierarchical_label_data))
 
         self._hierarchical_labels = LabelCollection(hierarchical_labels)
 
         # Initialize no-connect collection
         no_connect_data = self._data.get("no_connects", [])
-        no_connects = []
-        for no_connect_dict in no_connect_data:
-            if isinstance(no_connect_dict, dict):
-                # Convert dict to NoConnect object
-                position = no_connect_dict.get("position", {"x": 0, "y": 0})
-                if isinstance(position, dict):
-                    pos = Point(position["x"], position["y"])
-                elif isinstance(position, (list, tuple)):
-                    pos = Point(position[0], position[1])
-                else:
-                    pos = position
-
-                no_connect = NoConnect(
-                    uuid=no_connect_dict.get("uuid", str(uuid.uuid4())),
-                    position=pos,
-                )
-                no_connects.append(no_connect)
+        no_connects = ElementFactory.create_no_connects_from_list(no_connect_data)
         self._no_connects = NoConnectCollection(no_connects)
 
         # Initialize net collection
         net_data = self._data.get("nets", [])
-        nets = []
-        for net_dict in net_data:
-            if isinstance(net_dict, dict):
-                # Convert dict to Net object
-                net = Net(
-                    name=net_dict.get("name", ""),
-                    components=net_dict.get("components", []),
-                    wires=net_dict.get("wires", []),
-                    labels=net_dict.get("labels", []),
-                )
-                nets.append(net)
+        nets = ElementFactory.create_nets_from_list(net_data)
         self._nets = NetCollection(nets)
 
         # Initialize specialized managers
@@ -337,10 +206,10 @@ class Schematic:
     def create(
         cls,
         name: str = "Untitled",
-        version: str = "20250114",
-        generator: str = "eeschema",
-        generator_version: str = "9.0",
-        paper: str = "A4",
+        version: str = None,
+        generator: str = None,
+        generator_version: str = None,
+        paper: str = None,
         uuid: str = None,
     ) -> "Schematic":
         """
@@ -348,15 +217,23 @@ class Schematic:
 
         Args:
             name: Schematic name
-            version: KiCAD version (default: "20250114")
-            generator: Generator name (default: "eeschema")
-            generator_version: Generator version (default: "9.0")
-            paper: Paper size (default: "A4")
+            version: KiCAD version (default from config)
+            generator: Generator name (default from config)
+            generator_version: Generator version (default from config)
+            paper: Paper size (default from config)
             uuid: Specific UUID (auto-generated if None)
 
         Returns:
             New empty Schematic object
         """
+        # Apply config defaults for None values
+        from .config import config
+
+        version = version or config.file_format.version_default
+        generator = generator or config.file_format.generator_default
+        generator_version = generator_version or config.file_format.generator_version_default
+        paper = paper or config.paper.default
+
         # Special handling for blank schematic test case to match reference exactly
         if name == "Blank Schematic":
             schematic_data = {
@@ -1542,6 +1419,192 @@ class Schematic:
                     # Recursively check nested elements
                     self._update_project_in_instances(element)
 
+    # ============================================================================
+    # Export Methods (using kicad-cli)
+    # ============================================================================
+
+    def run_erc(self, **kwargs):
+        """
+        Run Electrical Rule Check (ERC) on this schematic.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.erc.run_erc()
+                - output_path: Path for ERC report
+                - format: 'json' or 'report'
+                - severity: 'all', 'error', 'warning', 'exclusions'
+                - units: 'mm', 'in', 'mils'
+
+        Returns:
+            ErcReport with violations and summary
+
+        Example:
+            >>> report = sch.run_erc()
+            >>> if report.has_errors():
+            ...     print(f"Found {report.error_count} errors")
+        """
+        from kicad_sch_api.cli.erc import run_erc
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before running ERC")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return run_erc(self._file_path, **kwargs)
+
+    def export_netlist(self, format="kicadsexpr", **kwargs):
+        """
+        Export netlist from this schematic.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            format: Netlist format (default: 'kicadsexpr')
+                - kicadsexpr: KiCad S-expression (default)
+                - kicadxml: KiCad XML
+                - spice: SPICE netlist
+                - spicemodel: SPICE with models
+                - cadstar, orcadpcb2, pads, allegro
+            **kwargs: Arguments passed to cli.netlist.export_netlist()
+
+        Returns:
+            Path to generated netlist file
+
+        Example:
+            >>> netlist = sch.export_netlist(format='spice')
+            >>> print(f"Netlist: {netlist}")
+        """
+        from kicad_sch_api.cli.netlist import export_netlist
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting netlist")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_netlist(self._file_path, format=format, **kwargs)
+
+    def export_bom(self, **kwargs):
+        """
+        Export Bill of Materials (BOM) from this schematic.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.bom.export_bom()
+                - output_path: Path for BOM file
+                - fields: List of fields to export
+                - group_by: Fields to group by
+                - exclude_dnp: Exclude Do-Not-Populate components
+                - And many more options...
+
+        Returns:
+            Path to generated BOM file
+
+        Example:
+            >>> bom = sch.export_bom(
+            ...     fields=['Reference', 'Value', 'Footprint', 'MPN'],
+            ...     group_by=['Value', 'Footprint'],
+            ...     exclude_dnp=True,
+            ... )
+        """
+        from kicad_sch_api.cli.bom import export_bom
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting BOM")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_bom(self._file_path, **kwargs)
+
+    def export_pdf(self, **kwargs):
+        """
+        Export schematic as PDF.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.export_docs.export_pdf()
+                - output_path: Path for PDF file
+                - theme: Color theme
+                - black_and_white: B&W export
+                - And more options...
+
+        Returns:
+            Path to generated PDF file
+
+        Example:
+            >>> pdf = sch.export_pdf(theme='Kicad Classic')
+        """
+        from kicad_sch_api.cli.export_docs import export_pdf
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting PDF")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_pdf(self._file_path, **kwargs)
+
+    def export_svg(self, **kwargs):
+        """
+        Export schematic as SVG.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.export_docs.export_svg()
+                - output_dir: Output directory
+                - theme: Color theme
+                - black_and_white: B&W export
+                - And more options...
+
+        Returns:
+            List of paths to generated SVG files
+
+        Example:
+            >>> svgs = sch.export_svg()
+            >>> for svg in svgs:
+            ...     print(f"Generated: {svg}")
+        """
+        from kicad_sch_api.cli.export_docs import export_svg
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting SVG")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_svg(self._file_path, **kwargs)
+
+    def export_dxf(self, **kwargs):
+        """
+        Export schematic as DXF.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.export_docs.export_dxf()
+
+        Returns:
+            List of paths to generated DXF files
+
+        Example:
+            >>> dxfs = sch.export_dxf()
+        """
+        from kicad_sch_api.cli.export_docs import export_dxf
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting DXF")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_dxf(self._file_path, **kwargs)
+
     def __str__(self) -> str:
         """String representation."""
         title = self.title_block.get("title", "Untitled")

kicad_sch_api/core/texts.py

@@ -10,6 +10,7 @@ import uuid
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
 
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
+from .collections import BaseCollection
 from .types import Point, Text
 
 logger = logging.getLogger(__name__)
@@ -124,10 +125,13 @@ class TextElement:
         return f"<Text '{self.text}' @ {self.position}>"
 
 
-class TextCollection:
+class TextCollection(BaseCollection[TextElement]):
     """
     Collection class for efficient text element management.
 
+    Inherits from BaseCollection for standard operations and adds text-specific
+    functionality including content-based indexing.
+
     Provides fast lookup, filtering, and bulk operations for schematic text elements.
     """
 
@@ -138,18 +142,17 @@ class TextCollection:
         Args:
             texts: Initial list of text data
         """
-        self._texts: List[TextElement] = []
-        self._uuid_index: Dict[str, TextElement] = {}
+        # Initialize base collection with empty list (we'll add elements below)
+        super().__init__([], collection_name="texts")
+
+        # Additional text-specific index
         self._content_index: Dict[str, List[TextElement]] = {}
-        self._modified = False
 
         # Add initial texts
         if texts:
             for text_data in texts:
                 self._add_to_indexes(TextElement(text_data, self))
 
-        logger.debug(f"TextCollection initialized with {len(self._texts)} texts")
-
     def add(
         self,
         text: str,
@@ -209,15 +212,10 @@ class TextCollection:
         # Create wrapper and add to collection
         text_element = TextElement(text_data, self)
         self._add_to_indexes(text_element)
-        self._mark_modified()
 
         logger.debug(f"Added text: {text_element}")
         return text_element
 
-    def get(self, text_uuid: str) -> Optional[TextElement]:
-        """Get text by UUID."""
-        return self._uuid_index.get(text_uuid)
-
     def remove(self, text_uuid: str) -> bool:
         """
         Remove text by UUID.
@@ -228,13 +226,19 @@ class TextCollection:
         Returns:
             True if text was removed, False if not found
         """
-        text_element = self._uuid_index.get(text_uuid)
+        text_element = self.get(text_uuid)
         if not text_element:
             return False
 
-        # Remove from indexes
-        self._remove_from_indexes(text_element)
-        self._mark_modified()
+        # Remove from content index
+        content = text_element.text
+        if content in self._content_index:
+            self._content_index[content].remove(text_element)
+            if not self._content_index[content]:
+                del self._content_index[content]
+
+        # Remove using base class method
+        super().remove(text_uuid)
 
         logger.debug(f"Removed text: {text_element}")
         return True
@@ -254,14 +258,14 @@ class TextCollection:
             return self._content_index.get(content, []).copy()
         else:
             matches = []
-            for text_element in self._texts:
+            for text_element in self._items:
                 if content.lower() in text_element.text.lower():
                     matches.append(text_element)
             return matches
 
     def filter(self, predicate: Callable[[TextElement], bool]) -> List[TextElement]:
         """
-        Filter texts by predicate function.
+        Filter texts by predicate function (delegates to base class find).
 
         Args:
             predicate: Function that returns True for texts to include
@@ -269,7 +273,7 @@ class TextCollection:
         Returns:
             List of texts matching predicate
         """
-        return [text for text in self._texts if predicate(text)]
+        return self.find(predicate)
 
     def bulk_update(self, criteria: Callable[[TextElement], bool], updates: Dict[str, Any]):
         """
@@ -280,7 +284,7 @@ class TextCollection:
             updates: Dictionary of property updates
         """
         updated_count = 0
-        for text_element in self._texts:
+        for text_element in self._items:
             if criteria(text_element):
                 for prop, value in updates.items():
                     if hasattr(text_element, prop):
@@ -293,15 +297,12 @@ class TextCollection:
 
     def clear(self):
         """Remove all texts from collection."""
-        self._texts.clear()
-        self._uuid_index.clear()
         self._content_index.clear()
-        self._mark_modified()
+        super().clear()
 
     def _add_to_indexes(self, text_element: TextElement):
-        """Add text to internal indexes."""
-        self._texts.append(text_element)
-        self._uuid_index[text_element.uuid] = text_element
+        """Add text to internal indexes (base + content index)."""
+        self._add_item(text_element)
 
         # Add to content index
         content = text_element.text
@@ -309,35 +310,7 @@ class TextCollection:
             self._content_index[content] = []
         self._content_index[content].append(text_element)
 
-    def _remove_from_indexes(self, text_element: TextElement):
-        """Remove text from internal indexes."""
-        self._texts.remove(text_element)
-        del self._uuid_index[text_element.uuid]
-
-        # Remove from content index
-        content = text_element.text
-        if content in self._content_index:
-            self._content_index[content].remove(text_element)
-            if not self._content_index[content]:
-                del self._content_index[content]
-
-    def _mark_modified(self):
-        """Mark collection as modified."""
-        self._modified = True
-
-    # Collection interface methods
-    def __len__(self) -> int:
-        """Return number of texts."""
-        return len(self._texts)
-
-    def __iter__(self) -> Iterator[TextElement]:
-        """Iterate over texts."""
-        return iter(self._texts)
-
-    def __getitem__(self, index: int) -> TextElement:
-        """Get text by index."""
-        return self._texts[index]
-
+    # Collection interface methods - __len__, __iter__, __getitem__ inherited from BaseCollection
     def __bool__(self) -> bool:
         """Return True if collection has texts."""
-        return len(self._texts) > 0
+        return len(self._items) > 0