mfcli 0.2.0__py3-none-any.whl

mfcli/pipeline/parsers/netlist/kicad_legacy_net.py

@@ -0,0 +1,326 @@
+"""
+KiCad Legacy Netlist Parser
+
+Parses KiCad legacy netlist files (.net) in S-expression format.
+Extracts:
+- Reference designators (ref_des)
+- Part numbers (from value or PARTNUMBER property)
+- Pin connections from nets section
+
+Format:
+    (export (version "E")
+      (components
+        (comp (ref "C1")
+          (value "PART_NUMBER")
+          (property (name "PARTNUMBER") (value "..."))))
+      (nets
+        (net (code "1") (name "GND")
+          (node (ref "C1") (pin "1")))))
+"""
+
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from mfcli.models.netlist import Component, NetlistSchema, Pin
+
+
+# ============================================================================
+# S-Expression Parser
+# ============================================================================
+
+class SExpression:
+    """Represents a parsed S-expression."""
+
+    def __init__(self, value: Optional[str] = None, children: Optional[List['SExpression']] = None):
+        self.value = value  # String value for atoms, None for lists
+        self.children = children or []  # Child expressions for lists
+
+    def is_list(self) -> bool:
+        """Check if this is a list (not an atom)."""
+        return self.value is None
+
+    def find(self, key: str) -> Optional['SExpression']:
+        """Find first child with matching value."""
+        for child in self.children:
+            if child.is_list() and child.children and child.children[0].value == key:
+                return child
+        return None
+
+    def find_all(self, key: str) -> List['SExpression']:
+        """Find all children with matching value."""
+        results = []
+        for child in self.children:
+            if child.is_list() and child.children and child.children[0].value == key:
+                results.append(child)
+        return results
+
+    def get_value(self, index: int = 0) -> Optional[str]:
+        """Get value at index from children."""
+        if index < len(self.children):
+            return self.children[index].value
+        return None
+
+    @staticmethod
+    def parse(text: str) -> List['SExpression']:
+        """Parse S-expression text into tree structure."""
+        tokens = SExpression._tokenize(text)
+        expressions, _ = SExpression._parse_tokens(tokens, 0)
+        return expressions
+
+    @staticmethod
+    def _tokenize(text: str) -> List[str]:
+        """Tokenize S-expression text."""
+        tokens = []
+        i = 0
+        while i < len(text):
+            char = text[i]
+
+            # Skip whitespace
+            if char.isspace():
+                i += 1
+                continue
+
+            # Handle parentheses
+            if char in '()':
+                tokens.append(char)
+                i += 1
+                continue
+
+            # Handle quoted strings
+            if char == '"':
+                j = i + 1
+                while j < len(text) and text[j] != '"':
+                    if text[j] == '\\':
+                        j += 2  # Skip escaped character
+                    else:
+                        j += 1
+                tokens.append(text[i:j + 1])  # Include quotes
+                i = j + 1
+                continue
+
+            # Handle atoms (unquoted strings)
+            j = i
+            while j < len(text) and not text[j].isspace() and text[j] not in '()':
+                j += 1
+            tokens.append(text[i:j])
+            i = j
+
+        return tokens
+
+    @staticmethod
+    def _parse_tokens(tokens: List[str], pos: int) -> Tuple[List['SExpression'], int]:
+        """Parse tokens into S-expressions, returns (expressions, next_pos)."""
+        expressions = []
+
+        while pos < len(tokens):
+            token = tokens[pos]
+
+            if token == '(':
+                # Start of list
+                children, pos = SExpression._parse_tokens(tokens, pos + 1)
+                expressions.append(SExpression(children=children))
+
+            elif token == ')':
+                # End of list
+                return expressions, pos + 1
+
+            else:
+                # Atom - remove quotes if present
+                value = token.strip('"')
+                expressions.append(SExpression(value=value))
+                pos += 1
+
+        return expressions, pos
+
+
+# ============================================================================
+# KiCad Legacy Netlist Parser
+# ============================================================================
+
+class KiCadLegacyNetParser:
+    """Parser for KiCad legacy netlist files."""
+
+    def __init__(self, content: str):
+        self.content = content
+        self.root: Optional[SExpression] = None
+        self.components_map: Dict[str, str] = {}  # ref_des -> part_number
+        self.nets_map: Dict[str, List[Tuple[str, str]]] = defaultdict(list)  # net_name -> [(ref_des, pin), ...]
+
+    def parse(self) -> NetlistSchema:
+        """Parse content and return validated schema."""
+        # Parse S-expressions
+        self.root = SExpression.parse(self.content)
+
+        if not self.root:
+            raise ValueError("Failed to parse S-expression")
+
+        # Find export section
+        export = None
+        for expr in self.root:
+            if expr.is_list() and expr.get_value(0) == "export":
+                export = expr
+                break
+
+        if not export:
+            raise ValueError("No (export ...) section found")
+
+        # Extract components and nets
+        self._extract_components(export)
+        self._extract_nets(export)
+
+        # Build schema
+        return self._build_schema()
+
+    def _extract_components(self, export: SExpression):
+        """Extract components from (components ...) section."""
+        components_section = export.find("components")
+        if not components_section:
+            return
+
+        # Find all (comp ...) entries
+        for comp in components_section.find_all("comp"):
+            ref_des = self._get_component_ref(comp)
+            part_number = self._get_component_part_number(comp)
+
+            if ref_des and part_number:
+                self.components_map[ref_des] = part_number
+
+    def _get_component_ref(self, comp: SExpression) -> Optional[str]:
+        """Extract reference designator from (comp ...) section."""
+        ref_expr = comp.find("ref")
+        if ref_expr and len(ref_expr.children) > 1:
+            return ref_expr.children[1].value
+        return None
+
+    def _get_component_part_number(self, comp: SExpression) -> Optional[str]:
+        """
+        Extract part number from (comp ...) section.
+        Try (value ...) first, then (property (name "PARTNUMBER") ...).
+        """
+        # Try (value ...) - most common
+        value_expr = comp.find("value")
+        if value_expr and len(value_expr.children) > 1:
+            part_number = value_expr.children[1].value
+            if part_number:
+                return part_number
+
+        # Try (property (name "PARTNUMBER") (value "..."))
+        for prop in comp.find_all("property"):
+            name_expr = prop.find("name")
+            if name_expr and len(name_expr.children) > 1:
+                if name_expr.children[1].value == "PARTNUMBER":
+                    value_expr = prop.find("value")
+                    if value_expr and len(value_expr.children) > 1:
+                        return value_expr.children[1].value
+
+        return None
+
+    def _extract_nets(self, export: SExpression):
+        """Extract nets from (nets ...) section."""
+        nets_section = export.find("nets")
+        if not nets_section:
+            return
+
+        # Find all (net ...) entries
+        for net in nets_section.find_all("net"):
+            net_name = self._get_net_name(net)
+            if not net_name:
+                continue
+
+            # Find all (node ...) entries
+            for node in net.find_all("node"):
+                ref_des, pin = self._get_node_info(node)
+                if ref_des and pin:
+                    self.nets_map[net_name].append((ref_des, pin))
+
+    def _get_net_name(self, net: SExpression) -> Optional[str]:
+        """Extract net name from (net ...) section."""
+        name_expr = net.find("name")
+        if name_expr and len(name_expr.children) > 1:
+            return name_expr.children[1].value
+        return None
+
+    def _get_node_info(self, node: SExpression) -> Tuple[Optional[str], Optional[str]]:
+        """Extract ref_des and pin from (node ...) section."""
+        ref_des = None
+        pin = None
+
+        ref_expr = node.find("ref")
+        if ref_expr and len(ref_expr.children) > 1:
+            ref_des = ref_expr.children[1].value
+
+        pin_expr = node.find("pin")
+        if pin_expr and len(pin_expr.children) > 1:
+            pin = pin_expr.children[1].value
+
+        return ref_des, pin
+
+    def _build_schema(self) -> NetlistSchema:
+        """Build NetlistSchema from extracted data."""
+        # Build pin list per component
+        component_pins: Dict[str, List[Pin]] = defaultdict(list)
+
+        for net_name, nodes in self.nets_map.items():
+            for ref_des, pin_number in nodes:
+                # Only add pins for known components
+                if ref_des in self.components_map:
+                    pin = Pin(
+                        pin=pin_number,
+                        net=net_name
+                    )
+                    component_pins[ref_des].append(pin)
+
+        # Build components list
+        components = []
+        for ref_des, part_number in self.components_map.items():
+            component = Component(
+                ref_des=ref_des,
+                part_number=part_number,
+                pins=component_pins[ref_des]
+            )
+            components.append(component)
+
+        return NetlistSchema(components=components)
+
+
+# ============================================================================
+# Main Function
+# ============================================================================
+
+def is_kicad_legacy_netlist(text: str) -> bool:
+    stripped = text.lstrip()
+    if not stripped.startswith("(export"):
+        return False
+
+    # MUST contain these blocks
+    keywords = ["(design", "(components", "(nets"]
+    return all(k in text for k in keywords)
+
+
+def parse_kicad_legacy_net_file(filepath: Path) -> NetlistSchema:
+    """
+    Parse a KiCad legacy netlist file and return validated netlist schema.
+    
+    Args:
+        filepath: Path to KiCad legacy netlist file (.net)
+        
+    Returns:
+        NetlistSchema with components and pins
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValidationError: If parsed data doesn't match schema
+    """
+    if not filepath.exists():
+        raise FileNotFoundError(f"KiCad legacy netlist file not found: {filepath}")
+
+    # Read file content
+    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+        content = f.read()
+
+    # Parse
+    parser = KiCadLegacyNetParser(content)
+    schema = parser.parse()
+
+    return schema

mfcli/pipeline/parsers/netlist/kicad_spice.py

@@ -0,0 +1,135 @@
+"""
+KiCad SPICE Netlist Parser
+
+Parses KiCad-generated SPICE netlist files (.cir) and extracts:
+- Reference designators (ref_des)
+- Part numbers
+- Pin connections (inferred from node positions)
+
+SPICE Format:
+    RefDes Node1 Node2 ... PartNumber
+    Example: R14 Net-_J3-Pad1_ Net-_LED2-A-Pad6_ CRCW0402330RJNED
+
+Pin Mapping:
+    - 2-terminal components (R, C): pin1=node1, pin2=node2
+    - 3-terminal components (Q, transistors): pin1=node1, pin2=node2, pin3=node3
+    - Multi-terminal: numbered sequentially
+"""
+
+from pathlib import Path
+from typing import Dict
+
+from mfcli.models.netlist import Component, NetlistSchema, Pin
+
+
+# ============================================================================
+# KiCad SPICE Parser
+# ============================================================================
+
+class KiCadSpiceParser:
+    """Parser for KiCad SPICE netlist files."""
+
+    def __init__(self, spice_content: str):
+        self.content = spice_content
+        self.lines = [line.strip() for line in spice_content.strip().split('\n')]
+        self.components: Dict[str, Component] = {}
+
+    def parse(self) -> NetlistSchema:
+        """Parse SPICE content and return validated schema."""
+        for line in self.lines:
+            # Skip empty lines
+            if not line:
+                continue
+
+            # Skip SPICE directives (start with .)
+            if line.startswith('.'):
+                continue
+
+            # Parse component line
+            self._parse_component_line(line)
+
+        # Convert to list and return
+        components_list = list(self.components.values())
+        return NetlistSchema(components=components_list)
+
+    def _parse_component_line(self, line: str):
+        """
+        Parse a component line from SPICE netlist.
+        Format: RefDes Node1 Node2 ... NodeN PartNumber
+        """
+        tokens = line.split()
+
+        if len(tokens) < 2:
+            return  # Invalid line
+
+        ref_des = tokens[0]
+
+        # Last token is part number, middle tokens are nodes
+        if len(tokens) == 2:
+            # Special case: component with no connections (placeholder)
+            # Example: LED2 __LED2
+            part_number = tokens[1]
+            nodes = []
+        else:
+            part_number = tokens[-1]
+            nodes = tokens[1:-1]
+
+        # Skip placeholder components (nodes starting with __)
+        if nodes and all(node.startswith('__') for node in nodes):
+            return
+
+        # Create component
+        component = Component(
+            ref_des=ref_des,
+            part_number=part_number,
+            pins=[]
+        )
+
+        # Map nodes to pins
+        # Pin numbers are inferred from node position (1, 2, 3, ...)
+        for pin_num, node_name in enumerate(nodes, start=1):
+            # Skip placeholder nodes
+            if node_name.startswith('__'):
+                continue
+
+            pin = Pin(
+                pin=str(pin_num),
+                net=node_name
+            )
+            component.pins.append(pin)
+
+        # Only add component if it has pins (skip placeholders)
+        if component.pins:
+            self.components[ref_des] = component
+
+
+# ============================================================================
+# Main Function
+# ============================================================================
+
+def parse_kicad_spice_file(filepath: Path) -> NetlistSchema:
+    """
+    Parse a KiCad SPICE netlist file and return validated netlist schema.
+    
+    Args:
+        filepath: Path to KiCad SPICE netlist file (.cir)
+        
+    Returns:
+        NetlistSchema with components and pins
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValidationError: If parsed data doesn't match schema
+    """
+    if not filepath.exists():
+        raise FileNotFoundError(f"KiCad SPICE netlist file not found: {filepath}")
+
+    # Read file content
+    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+        content = f.read()
+
+    # Parse
+    parser = KiCadSpiceParser(content)
+    schema = parser.parse()
+
+    return schema

mfcli/pipeline/parsers/netlist/pads.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+PADS Netlist Parser
+
+Parses PADS netlist files (Mentor Graphics) and extracts:
+- Reference designators (ref_des)
+- Part numbers/footprints
+- Pin connections (pin number + net name)
+
+Usage:
+    python pads_parser.py <netlist.txt> [--output <output.json>]
+
+Example:
+    python pads_parser.py design.asc --output parsed.json
+"""
+
+from pathlib import Path
+from typing import Dict
+
+from mfcli.models.netlist import Component, NetlistSchema, Pin
+
+
+# ============================================================================
+# PADS Parser
+# ============================================================================
+
+class PADSParser:
+    """Parser for PADS netlist files."""
+
+    def __init__(self, pads_content: str):
+        self.content = pads_content
+        self.lines = [line.strip() for line in pads_content.strip().split('\n')]
+        self.components: Dict[str, Component] = {}
+
+    def parse(self) -> NetlistSchema:
+        """Parse PADS content and return validated schema."""
+        # Step 1: Validate header
+        if not self._validate_header():
+            raise ValueError("Not a valid PADS netlist file (missing *PADS-PCB* header)")
+
+        # Step 2: Find section boundaries
+        part_start, part_end = self._find_section('*PART*')
+        net_start, net_end = self._find_section('*NET*')
+
+        # Step 3: Parse components
+        if part_start is not None and part_end is not None:
+            self._parse_parts(part_start, part_end)
+
+        # Step 4: Parse nets and add pins to components
+        if net_start is not None and net_end is not None:
+            self._parse_nets(net_start, net_end)
+
+        # Step 5: Validate and return
+        components_list = list(self.components.values())
+        return NetlistSchema(components=components_list)
+
+    def _validate_header(self) -> bool:
+        """Check if file has PADS header."""
+        return len(self.lines) > 0 and self.lines[0].startswith('*PADS-PCB*')
+
+    def _find_section(self, section_name: str) -> tuple:
+        """Find start and end indices of a section."""
+        try:
+            start_idx = self.lines.index(section_name) + 1
+
+            # Find end of section (next TOP-LEVEL section marker or *END*)
+            # Top-level markers: *PART*, *NET*, *END* (not *SIGNAL*)
+            top_level_markers = ['*PART*', '*NET*', '*END*']
+            end_idx = len(self.lines)
+            for i in range(start_idx, len(self.lines)):
+                if self.lines[i] in top_level_markers and self.lines[i] != section_name:
+                    end_idx = i
+                    break
+
+            return start_idx, end_idx
+        except ValueError:
+            return None, None
+
+    def _parse_parts(self, start_idx: int, end_idx: int):
+        """Parse the *PART* section to extract components."""
+        for i in range(start_idx, end_idx):
+            line = self.lines[i]
+
+            # Skip empty lines and section markers
+            if not line or line.startswith('*'):
+                continue
+
+            # Split line into ref_des and part_number
+            parts = line.split(None, 1)  # Split on first whitespace
+            if len(parts) >= 1:
+                ref_des = parts[0]
+                part_number = parts[1] if len(parts) > 1 else ""
+
+                # Create component
+                self.components[ref_des] = Component(
+                    ref_des=ref_des,
+                    part_number=part_number,
+                    pins=[]
+                )
+
+    def _parse_nets(self, start_idx: int, end_idx: int):
+        """Parse the *NET* section to extract pin connections."""
+        current_net = None
+
+        for i in range(start_idx, end_idx):
+            line = self.lines[i]
+
+            # Skip empty lines
+            if not line:
+                continue
+
+            # Check for signal/net definition
+            if line.startswith('*SIGNAL*'):
+                # Extract net name (everything after *SIGNAL*)
+                parts = line.split(None, 1)
+                if len(parts) > 1:
+                    current_net = parts[1]
+                continue
+
+            # Skip other section markers
+            if line.startswith('*'):
+                current_net = None
+                continue
+
+            # Parse pin references if we have a current net
+            if current_net:
+                self._parse_pin_references(line, current_net)
+
+    def _parse_pin_references(self, line: str, net_name: str):
+        """Parse pin references from a line and add to components."""
+        # Split line into individual pin references
+        pin_refs = line.split()
+
+        for pin_ref in pin_refs:
+            # Skip empty strings
+            if not pin_ref:
+                continue
+
+            # Pin format: RefDes.PinNumber (e.g., C1.2, R14.1)
+            if '.' in pin_ref:
+                parts = pin_ref.split('.', 1)
+                ref_des = parts[0]
+                pin_number = parts[1]
+
+                # Add pin to component if component exists
+                if ref_des in self.components:
+                    pin = Pin(pin=pin_number, net=net_name)
+
+                    # Avoid duplicates
+                    existing_pins = self.components[ref_des].pins
+                    if not any(p.pin == pin.pin and p.net == pin.net for p in existing_pins):
+                        self.components[ref_des].pins.append(pin)
+
+
+# ============================================================================
+# Main Functions
+# ============================================================================
+
+def parse_pads_file(filepath: Path) -> NetlistSchema:
+    """
+    Parse a PADS netlist file and return validated netlist schema.
+    
+    Args:
+        filepath: Path to PADS netlist file
+        
+    Returns:
+        NetlistSchema with components and pins
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValidationError: If parsed data doesn't match schema
+        ValueError: If file is not a valid PADS netlist
+    """
+    if not filepath.exists():
+        raise FileNotFoundError(f"PADS netlist file not found: {filepath}")
+
+    # Read file content
+    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+        content = f.read()
+
+    # Parse
+    parser = PADSParser(content)
+    schema = parser.parse()
+
+    return schema