kicad-sch-api 0.3.2__tar.gz → 0.3.4__tar.gz

{kicad_sch_api-0.3.2/kicad_sch_api.egg-info → kicad_sch_api-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.3.2
+Version: 0.3.4
 Summary: Professional KiCAD schematic manipulation library with exact format preservation
 Author-email: Circuit-Synth <shane@circuit-synth.com>
 Maintainer-email: Circuit-Synth <shane@circuit-synth.com>

{kicad_sch_api-0.3.2 → kicad_sch_api-0.3.4}/kicad_sch_api/__init__.py

@@ -42,7 +42,7 @@ Advanced Usage:
         print(f"Found {len(issues)} validation issues")
 """
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"
 __author__ = "Circuit-Synth"
 __email__ = "info@circuit-synth.com"
 
@@ -55,7 +55,7 @@ from .library.cache import SymbolLibraryCache, get_symbol_cache
 from .utils.validation import ValidationError, ValidationIssue
 
 # Version info
-VERSION_INFO = (0, 3, 2)
+VERSION_INFO = (0, 3, 3)
 
 # Public API
 __all__ = [

{kicad_sch_api-0.3.2 → kicad_sch_api-0.3.4}/kicad_sch_api/core/formatter.py

@@ -146,6 +146,9 @@ class ExactFormatter:
         self.rules["embedded_fonts"] = FormatRule(inline=True)
         self.rules["page"] = FormatRule(inline=True, quote_indices={1})
 
+        # Image element
+        self.rules["image"] = FormatRule(inline=False, custom_handler=self._format_image)
+
     def format(self, data: Any) -> str:
         """
         Format S-expression data with exact KiCAD formatting.
@@ -511,6 +514,34 @@ class ExactFormatter:
         result += f"\n{indent})"
         return result
 
+    def _format_image(self, lst: List[Any], indent_level: int) -> str:
+        """Format image elements with base64 data split across lines."""
+        indent = "\t" * indent_level
+        next_indent = "\t" * (indent_level + 1)
+
+        result = f"({lst[0]}"
+
+        # Process each element
+        for element in lst[1:]:
+            if isinstance(element, list):
+                tag = str(element[0]) if element else ""
+                if tag == "data":
+                    # Special handling for data element
+                    # First chunk on same line as (data, rest on subsequent lines
+                    if len(element) > 1:
+                        result += f'\n{next_indent}({element[0]} "{element[1]}"'
+                        for chunk in element[2:]:
+                            result += f'\n{next_indent}\t"{chunk}"'
+                        result += f"\n{next_indent})"
+                    else:
+                        result += f"\n{next_indent}({element[0]})"
+                else:
+                    # Regular element formatting
+                    result += f"\n{next_indent}{self._format_element(element, indent_level + 1)}"
+
+        result += f"\n{indent})"
+        return result
+
 
 class CompactFormatter(ExactFormatter):
     """Compact formatter for minimal output size."""

{kicad_sch_api-0.3.2 → kicad_sch_api-0.3.4}/kicad_sch_api/core/parser.py

@@ -197,6 +197,7 @@ class SExpressionParser:
             "circles": [],
             "beziers": [],
             "rectangles": [],
+            "images": [],
             "nets": [],
             "lib_symbols": {},
             "sheet_instances": [],
@@ -282,6 +283,10 @@ class SExpressionParser:
                 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":
@@ -357,6 +362,10 @@ class SExpressionParser:
         for graphic in schematic_data.get("graphics", []):
             sexp_data.append(self._graphic_to_sexp(graphic))
 
+        # 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))
@@ -1108,6 +1117,37 @@ class SExpressionParser:
 
         return rectangle if rectangle else None
 
+    def _parse_image(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse an image element."""
+        # Format: (image (at x y) (uuid "...") (data "base64..."))
+        image = {
+            "position": {"x": 0, "y": 0},
+            "data": "",
+            "scale": 1.0,
+            "uuid": None
+        }
+
+        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" and len(elem) >= 3:
+                image["position"] = {"x": float(elem[1]), "y": float(elem[2])}
+            elif elem_type == "scale" and len(elem) >= 2:
+                image["scale"] = float(elem[1])
+            elif elem_type == "data" and len(elem) >= 2:
+                # The data can be spread across multiple string elements
+                data_parts = []
+                for data_elem in elem[1:]:
+                    data_parts.append(str(data_elem).strip('"'))
+                image["data"] = "".join(data_parts)
+            elif elem_type == "uuid" and len(elem) >= 2:
+                image["uuid"] = str(elem[1]).strip('"')
+
+        return image if image.get("uuid") and image.get("data") else None
+
     def _parse_lib_symbols(self, item: List[Any]) -> Dict[str, Any]:
         """Parse lib_symbols section."""
         # Implementation for lib_symbols parsing
@@ -1933,6 +1973,38 @@ class SExpressionParser:
 
         return sexp
 
+    def _image_to_sexp(self, image_data: Dict[str, Any]) -> List[Any]:
+        """Convert image element to S-expression."""
+        sexp = [sexpdata.Symbol("image")]
+
+        # Add position
+        position = image_data.get("position", {"x": 0, "y": 0})
+        pos_x, pos_y = position["x"], position["y"]
+        sexp.append([sexpdata.Symbol("at"), pos_x, pos_y])
+
+        # Add UUID
+        if "uuid" in image_data:
+            sexp.append([sexpdata.Symbol("uuid"), image_data["uuid"]])
+
+        # Add scale if not default
+        scale = image_data.get("scale", 1.0)
+        if scale != 1.0:
+            sexp.append([sexpdata.Symbol("scale"), scale])
+
+        # Add image data
+        # KiCad splits base64 data into multiple lines for readability
+        # Each line is roughly 76 characters (standard base64 line length)
+        data = image_data.get("data", "")
+        if data:
+            data_sexp = [sexpdata.Symbol("data")]
+            # Split the data into 76-character chunks
+            chunk_size = 76
+            for i in range(0, len(data), chunk_size):
+                data_sexp.append(data[i:i+chunk_size])
+            sexp.append(data_sexp)
+
+        return sexp
+
     def _lib_symbols_to_sexp(self, lib_symbols: Dict[str, Any]) -> List[Any]:
         """Convert lib_symbols to S-expression."""
         sexp = [sexpdata.Symbol("lib_symbols")]

{kicad_sch_api-0.3.2 → kicad_sch_api-0.3.4}/kicad_sch_api/core/schematic.py

@@ -1138,6 +1138,55 @@ class Schematic:
         logger.debug(f"Added text box: '{text}' at {position} size {size}")
         return text_box.uuid
 
+    def add_image(
+        self,
+        position: Union[Point, Tuple[float, float]],
+        data: str,
+        scale: float = 1.0,
+        uuid: Optional[str] = None,
+    ) -> str:
+        """
+        Add an image element.
+
+        Args:
+            position: Image position
+            data: Base64-encoded image data
+            scale: Image scale factor (default 1.0)
+            uuid: Optional UUID (auto-generated if None)
+
+        Returns:
+            UUID of created image element
+        """
+        if isinstance(position, tuple):
+            position = Point(position[0], position[1])
+
+        from .types import Image
+
+        import uuid as uuid_module
+
+        image = Image(
+            uuid=uuid if uuid else str(uuid_module.uuid4()),
+            position=position,
+            data=data,
+            scale=scale,
+        )
+
+        if "images" not in self._data:
+            self._data["images"] = []
+
+        self._data["images"].append(
+            {
+                "uuid": image.uuid,
+                "position": {"x": image.position.x, "y": image.position.y},
+                "data": image.data,
+                "scale": image.scale,
+            }
+        )
+        self._modified = True
+
+        logger.debug(f"Added image at {position} with {len(data)} bytes of data")
+        return image.uuid
+
     def add_rectangle(
         self,
         start: Union[Point, Tuple[float, float]],
@@ -1592,9 +1641,7 @@ class Schematic:
                     break
 
         # Fix string/symbol conversion issues in pin definitions
-        print(f"🔧 DEBUG: Before fix - checking for pin definitions...")
         self._fix_symbol_strings_recursively(modified_data)
-        print(f"🔧 DEBUG: After fix - symbol strings fixed")
 
         return modified_data
 
@@ -1607,15 +1654,10 @@ class Schematic:
                 if isinstance(item, list):
                     # Check for pin definitions that need fixing
                     if len(item) >= 3 and item[0] == sexpdata.Symbol("pin"):
-                        print(
-                            f"🔧 DEBUG: Found pin definition: {item[:3]} - types: {[type(x) for x in item[:3]]}"
-                        )
                         # Fix pin type and shape - ensure they are symbols not strings
                         if isinstance(item[1], str):
-                            print(f"🔧 DEBUG: Converting pin type '{item[1]}' to symbol")
                             item[1] = sexpdata.Symbol(item[1])  # pin type: "passive" -> passive
                         if len(item) >= 3 and isinstance(item[2], str):
-                            print(f"🔧 DEBUG: Converting pin shape '{item[2]}' to symbol")
                             item[2] = sexpdata.Symbol(item[2])  # pin shape: "line" -> line
 
                     # Recursively process nested lists

{kicad_sch_api-0.3.2 → kicad_sch_api-0.3.4}/kicad_sch_api/core/types.py

@@ -372,6 +372,20 @@ class SchematicRectangle:
         )
 
 
+@dataclass
+class Image:
+    """Image element in schematic."""
+
+    uuid: str
+    position: Point
+    data: str  # Base64-encoded image data
+    scale: float = 1.0
+
+    def __post_init__(self):
+        if not self.uuid:
+            self.uuid = str(uuid4())
+
+
 @dataclass
 class Net:
     """Electrical net connecting components."""

kicad_sch_api-0.3.4/kicad_sch_api/geometry/__init__.py

@@ -0,0 +1,26 @@
+"""
+Geometry module for KiCad schematic symbol bounding box calculations.
+
+This module provides accurate bounding box calculations for KiCad symbols,
+including font metrics and symbol geometry analysis.
+
+Migrated from circuit-synth to kicad-sch-api for better architectural separation.
+"""
+
+from .font_metrics import (
+    DEFAULT_PIN_LENGTH,
+    DEFAULT_PIN_NAME_OFFSET,
+    DEFAULT_PIN_NUMBER_SIZE,
+    DEFAULT_PIN_TEXT_WIDTH_RATIO,
+    DEFAULT_TEXT_HEIGHT,
+)
+from .symbol_bbox import SymbolBoundingBoxCalculator
+
+__all__ = [
+    "SymbolBoundingBoxCalculator",
+    "DEFAULT_TEXT_HEIGHT",
+    "DEFAULT_PIN_LENGTH",
+    "DEFAULT_PIN_NAME_OFFSET",
+    "DEFAULT_PIN_NUMBER_SIZE",
+    "DEFAULT_PIN_TEXT_WIDTH_RATIO",
+]

kicad_sch_api-0.3.4/kicad_sch_api/geometry/font_metrics.py

@@ -0,0 +1,20 @@
+"""
+Font metrics and text rendering constants for KiCad schematic text.
+
+These constants are used for accurate text bounding box calculations
+and symbol spacing in schematic layouts.
+"""
+
+# KiCad default text size in mm
+# Increased to better match actual KiCad rendering
+DEFAULT_TEXT_HEIGHT = 2.54  # 100 mils (doubled from 50 mils)
+
+# Default pin dimensions
+DEFAULT_PIN_LENGTH = 2.54  # 100 mils
+DEFAULT_PIN_NAME_OFFSET = 0.508  # 20 mils - offset from pin endpoint to label text
+DEFAULT_PIN_NUMBER_SIZE = 1.27  # 50 mils
+
+# Text width ratio for proportional font rendering
+# KiCad uses proportional fonts where average character width is ~0.65x height
+# This prevents label text from extending beyond calculated bounding boxes
+DEFAULT_PIN_TEXT_WIDTH_RATIO = 0.65  # Width to height ratio for pin text (proportional font average)