kicad-sch-api 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

kicad_sch_api/core/wires.py

@@ -36,10 +36,10 @@ class WireCollection:
         self._wires: List[Wire] = wires or []
         self._uuid_index: Dict[str, int] = {}
         self._modified = False
-        
+
         # Build UUID index
         self._rebuild_index()
-        
+
         logger.debug(f"WireCollection initialized with {len(self._wires)} wires")
 
     def _rebuild_index(self):
@@ -67,7 +67,7 @@ class WireCollection:
         points: Optional[List[Union[Point, Tuple[float, float]]]] = None,
         wire_type: WireType = WireType.WIRE,
         stroke_width: float = 0.0,
-        uuid: Optional[str] = None
+        uuid: Optional[str] = None,
     ) -> str:
         """
         Add a wire to the collection.
@@ -112,12 +112,7 @@ class WireCollection:
             raise ValueError("Must provide either start/end points or points list")
 
         # Create wire
-        wire = Wire(
-            uuid=uuid,
-            points=wire_points,
-            wire_type=wire_type,
-            stroke_width=stroke_width
-        )
+        wire = Wire(uuid=uuid, points=wire_points, wire_type=wire_type, stroke_width=stroke_width)
 
         # Add to collection
         self._wires.append(wire)
@@ -148,17 +143,23 @@ class WireCollection:
         logger.debug(f"Removed wire: {uuid}")
         return True
 
-    def get_by_point(self, point: Union[Point, Tuple[float, float]], tolerance: float = 0.1) -> List[Wire]:
+    def get_by_point(
+        self, point: Union[Point, Tuple[float, float]], tolerance: float = None
+    ) -> List[Wire]:
         """
         Find wires that pass through or near a point.
 
         Args:
             point: Point to search near
-            tolerance: Distance tolerance
+            tolerance: Distance tolerance (uses config default if None)
 
         Returns:
             List of wires near the point
         """
+        if tolerance is None:
+            from .config import config
+
+            tolerance = config.tolerance.position_tolerance
         if isinstance(point, tuple):
             point = Point(point[0], point[1])
 
@@ -178,33 +179,36 @@ class WireCollection:
 
         return matching_wires
 
-    def _point_on_segment(self, point: Point, seg_start: Point, seg_end: Point, tolerance: float) -> bool:
+    def _point_on_segment(
+        self, point: Point, seg_start: Point, seg_end: Point, tolerance: float
+    ) -> bool:
         """Check if point lies on line segment within tolerance."""
         # Vector from seg_start to seg_end
         seg_vec = Point(seg_end.x - seg_start.x, seg_end.y - seg_start.y)
         seg_length = seg_start.distance_to(seg_end)
-        
-        if seg_length < 0.001:  # Very short segment
+
+        from .config import config
+
+        if seg_length < config.tolerance.wire_segment_min:  # Very short segment
             return seg_start.distance_to(point) <= tolerance
-        
+
         # Vector from seg_start to point
         point_vec = Point(point.x - seg_start.x, point.y - seg_start.y)
-        
+
         # Project point onto segment
-        dot_product = (point_vec.x * seg_vec.x + point_vec.y * seg_vec.y)
+        dot_product = point_vec.x * seg_vec.x + point_vec.y * seg_vec.y
         projection = dot_product / (seg_length * seg_length)
-        
+
         # Check if projection is within segment bounds
         if projection < 0 or projection > 1:
             return False
-        
+
         # Calculate distance from point to line
         proj_point = Point(
-            seg_start.x + projection * seg_vec.x,
-            seg_start.y + projection * seg_vec.y
+            seg_start.x + projection * seg_vec.x, seg_start.y + projection * seg_vec.y
         )
         distance = point.distance_to(proj_point)
-        
+
         return distance <= tolerance
 
     def get_horizontal_wires(self) -> List[Wire]:
@@ -220,7 +224,7 @@ class WireCollection:
         total_length = sum(wire.length for wire in self._wires)
         simple_wires = sum(1 for wire in self._wires if wire.is_simple())
         multi_point_wires = len(self._wires) - simple_wires
-        
+
         return {
             "total_wires": len(self._wires),
             "simple_wires": simple_wires,
@@ -228,7 +232,7 @@ class WireCollection:
             "total_length": total_length,
             "avg_length": total_length / len(self._wires) if self._wires else 0,
             "horizontal_wires": len(self.get_horizontal_wires()),
-            "vertical_wires": len(self.get_vertical_wires())
+            "vertical_wires": len(self.get_vertical_wires()),
         }
 
     def clear(self):
@@ -245,4 +249,4 @@ class WireCollection:
 
     def mark_saved(self):
         """Mark collection as saved (reset modified flag)."""
-        self._modified = False
+        self._modified = False

kicad_sch_api/discovery/__init__.py

@@ -7,4 +7,4 @@ using a SQLite search index built from the existing symbol cache.
 
 from .search_index import ComponentSearchIndex, get_search_index
 
-__all__ = ["ComponentSearchIndex", "get_search_index"]
+__all__ = ["ComponentSearchIndex", "get_search_index"]

kicad_sch_api/discovery/search_index.py

@@ -18,19 +18,20 @@ logger = logging.getLogger(__name__)
 
 class ComponentSearchIndex:
     """Fast SQLite-based search index for KiCAD components."""
-    
+
     def __init__(self, cache_dir: Optional[Path] = None):
         """Initialize the search index."""
         self.cache_dir = cache_dir or Path.home() / ".cache" / "kicad-sch-api"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
-        
+
         self.db_path = self.cache_dir / "search_index.db"
         self._init_database()
-    
+
     def _init_database(self):
         """Initialize the SQLite database schema."""
         with sqlite3.connect(str(self.db_path)) as conn:
-            conn.execute("""
+            conn.execute(
+                """
                 CREATE TABLE IF NOT EXISTS components (
                     lib_id TEXT PRIMARY KEY,
                     name TEXT NOT NULL,
@@ -42,110 +43,136 @@ class ComponentSearchIndex:
                     category TEXT DEFAULT '',
                     last_updated REAL DEFAULT 0
                 )
-            """)
-            
+            """
+            )
+
             # Create search indexes for fast queries
-            conn.execute("""
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_name 
                 ON components(name COLLATE NOCASE)
-            """)
-            
-            conn.execute("""
+            """
+            )
+
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_description 
                 ON components(description COLLATE NOCASE)
-            """)
-            
-            conn.execute("""
+            """
+            )
+
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_library 
                 ON components(library)
-            """)
-            
-            conn.execute("""
+            """
+            )
+
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_category 
                 ON components(category)
-            """)
-            
+            """
+            )
+
             # Full-text search virtual table for advanced queries
-            conn.execute("""
+            conn.execute(
+                """
                 CREATE VIRTUAL TABLE IF NOT EXISTS components_fts 
                 USING fts5(lib_id, name, description, keywords, content=components)
-            """)
-            
+            """
+            )
+
             conn.commit()
             logger.debug("Initialized search index database")
-    
+
     def rebuild_index(self, progress_callback: Optional[callable] = None) -> int:
         """Rebuild the search index from the symbol cache."""
         start_time = time.time()
         symbol_cache = get_symbol_cache()
-        
+
         # Get all cached symbols
         symbols = []
         for lib_name in symbol_cache._library_index.keys():
             try:
                 lib_symbols = symbol_cache.get_library_symbols(lib_name)
                 symbols.extend(lib_symbols)
-                
+
                 if progress_callback:
                     progress_callback(f"Indexing {lib_name}: {len(lib_symbols)} symbols")
-                    
+
             except Exception as e:
                 logger.warning(f"Failed to load library {lib_name}: {e}")
-        
+
         # Clear and rebuild index
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.execute("DELETE FROM components")
             conn.execute("DELETE FROM components_fts")
-            
+
             # Insert symbols in batches for better performance
             batch_size = 100
             for i in range(0, len(symbols), batch_size):
-                batch = symbols[i:i + batch_size]
-                
+                batch = symbols[i : i + batch_size]
+
                 # Prepare batch data
                 batch_data = []
                 for symbol in batch:
-                    batch_data.append((
-                        symbol.lib_id,
-                        symbol.name,
-                        symbol.library,
-                        symbol.description,
-                        symbol.keywords,
-                        symbol.reference_prefix,
-                        len(symbol.pins),
-                        self._categorize_component(symbol),
-                        time.time()
-                    ))
-                
+                    batch_data.append(
+                        (
+                            symbol.lib_id,
+                            symbol.name,
+                            symbol.library,
+                            symbol.description,
+                            symbol.keywords,
+                            symbol.reference_prefix,
+                            len(symbol.pins),
+                            self._categorize_component(symbol),
+                            time.time(),
+                        )
+                    )
+
                 # Insert batch
-                conn.executemany("""
+                conn.executemany(
+                    """
                     INSERT OR REPLACE INTO components
                     (lib_id, name, library, description, keywords, reference_prefix, 
                      pin_count, category, last_updated)
                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """, batch_data)
-                
+                """,
+                    batch_data,
+                )
+
                 # Update FTS table
-                conn.executemany("""
+                conn.executemany(
+                    """
                     INSERT OR REPLACE INTO components_fts
                     (lib_id, name, description, keywords)
                     VALUES (?, ?, ?, ?)
-                """, [(data[0], data[1], data[3], data[4]) for data in batch_data])
-                
+                """,
+                    [(data[0], data[1], data[3], data[4]) for data in batch_data],
+                )
+
                 if progress_callback:
-                    progress_callback(f"Indexed {min(i + batch_size, len(symbols))}/{len(symbols)} components")
-            
+                    progress_callback(
+                        f"Indexed {min(i + batch_size, len(symbols))}/{len(symbols)} components"
+                    )
+
             conn.commit()
-        
+
         elapsed = time.time() - start_time
         logger.info(f"Rebuilt search index with {len(symbols)} components in {elapsed:.2f}s")
         return len(symbols)
-    
-    def search(self, query: str, library: Optional[str] = None, 
-              category: Optional[str] = None, limit: int = 20) -> List[Dict[str, Any]]:
+
+    def search(
+        self,
+        query: str,
+        library: Optional[str] = None,
+        category: Optional[str] = None,
+        limit: int = 20,
+    ) -> List[Dict[str, Any]]:
         """Search components using multiple strategies."""
         results = []
-        
+
         # Try different search strategies
         strategies = [
             self._search_exact_match,
@@ -153,39 +180,40 @@ class ComponentSearchIndex:
             self._search_contains,
             self._search_fts,
         ]
-        
+
         for strategy in strategies:
             try:
                 strategy_results = strategy(query, library, category, limit - len(results))
-                
+
                 # Avoid duplicates
                 existing_ids = {r["lib_id"] for r in results}
                 new_results = [r for r in strategy_results if r["lib_id"] not in existing_ids]
-                
+
                 results.extend(new_results)
-                
+
                 if len(results) >= limit:
                     break
-                    
+
             except Exception as e:
                 logger.debug(f"Search strategy failed: {e}")
-        
+
         return results[:limit]
-    
-    def _search_exact_match(self, query: str, library: Optional[str], 
-                           category: Optional[str], limit: int) -> List[Dict[str, Any]]:
+
+    def _search_exact_match(
+        self, query: str, library: Optional[str], category: Optional[str], limit: int
+    ) -> List[Dict[str, Any]]:
         """Search for exact name matches."""
         conditions = ["name = ? COLLATE NOCASE"]
         params = [query]
-        
+
         if library:
             conditions.append("library = ?")
             params.append(library)
-        
+
         if category:
             conditions.append("category = ?")
             params.append(category)
-        
+
         sql = f"""
             SELECT lib_id, name, library, description, keywords, reference_prefix, 
                    pin_count, category, 1.0 as match_score
@@ -195,25 +223,26 @@ class ComponentSearchIndex:
             LIMIT ?
         """
         params.append(limit)
-        
+
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.row_factory = sqlite3.Row
             return [dict(row) for row in conn.execute(sql, params)]
-    
-    def _search_prefix_match(self, query: str, library: Optional[str], 
-                            category: Optional[str], limit: int) -> List[Dict[str, Any]]:
+
+    def _search_prefix_match(
+        self, query: str, library: Optional[str], category: Optional[str], limit: int
+    ) -> List[Dict[str, Any]]:
         """Search for components starting with query."""
         conditions = ["name LIKE ? COLLATE NOCASE"]
         params = [f"{query}%"]
-        
+
         if library:
             conditions.append("library = ?")
             params.append(library)
-        
+
         if category:
             conditions.append("category = ?")
             params.append(category)
-        
+
         sql = f"""
             SELECT lib_id, name, library, description, keywords, reference_prefix, 
                    pin_count, category, 0.8 as match_score
@@ -223,25 +252,26 @@ class ComponentSearchIndex:
             LIMIT ?
         """
         params.append(limit)
-        
+
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.row_factory = sqlite3.Row
             return [dict(row) for row in conn.execute(sql, params)]
-    
-    def _search_contains(self, query: str, library: Optional[str], 
-                        category: Optional[str], limit: int) -> List[Dict[str, Any]]:
+
+    def _search_contains(
+        self, query: str, library: Optional[str], category: Optional[str], limit: int
+    ) -> List[Dict[str, Any]]:
         """Search for components containing query in name or description."""
         conditions = ["(name LIKE ? COLLATE NOCASE OR description LIKE ? COLLATE NOCASE)"]
         params = [f"%{query}%", f"%{query}%"]
-        
+
         if library:
             conditions.append("library = ?")
             params.append(library)
-        
+
         if category:
             conditions.append("category = ?")
             params.append(category)
-        
+
         sql = f"""
             SELECT lib_id, name, library, description, keywords, reference_prefix, 
                    pin_count, category, 0.6 as match_score
@@ -253,17 +283,18 @@ class ComponentSearchIndex:
             LIMIT ?
         """
         params.extend([f"%{query}%", limit])
-        
+
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.row_factory = sqlite3.Row
             return [dict(row) for row in conn.execute(sql, params)]
-    
-    def _search_fts(self, query: str, library: Optional[str], 
-                   category: Optional[str], limit: int) -> List[Dict[str, Any]]:
+
+    def _search_fts(
+        self, query: str, library: Optional[str], category: Optional[str], limit: int
+    ) -> List[Dict[str, Any]]:
         """Full-text search using FTS5."""
         # Build FTS query
-        fts_query = ' '.join(f'"{term}"*' for term in query.split())
-        
+        fts_query = " ".join(f'"{term}"*' for term in query.split())
+
         sql = """
             SELECT c.lib_id, c.name, c.library, c.description, c.keywords, 
                    c.reference_prefix, c.pin_count, c.category, 
@@ -273,18 +304,18 @@ class ComponentSearchIndex:
             WHERE fts MATCH ?
         """
         params = [fts_query]
-        
+
         if library:
             sql += " AND c.library = ?"
             params.append(library)
-        
+
         if category:
             sql += " AND c.category = ?"
             params.append(category)
-        
+
         sql += " ORDER BY fts.rank LIMIT ?"
         params.append(limit)
-        
+
         try:
             with sqlite3.connect(str(self.db_path)) as conn:
                 conn.row_factory = sqlite3.Row
@@ -292,7 +323,7 @@ class ComponentSearchIndex:
         except sqlite3.OperationalError:
             # FTS query failed, return empty results
             return []
-    
+
     def get_libraries(self) -> List[Dict[str, Any]]:
         """Get all available libraries with component counts."""
         sql = """
@@ -301,11 +332,11 @@ class ComponentSearchIndex:
             GROUP BY library
             ORDER BY library
         """
-        
+
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.row_factory = sqlite3.Row
             return [dict(row) for row in conn.execute(sql)]
-    
+
     def get_categories(self) -> List[Dict[str, Any]]:
         """Get all component categories with counts."""
         sql = """
@@ -315,11 +346,11 @@ class ComponentSearchIndex:
             GROUP BY category
             ORDER BY component_count DESC
         """
-        
+
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.row_factory = sqlite3.Row
             return [dict(row) for row in conn.execute(sql)]
-    
+
     def validate_component(self, lib_id: str) -> Optional[Dict[str, Any]]:
         """Check if a component exists in the index."""
         sql = """
@@ -328,41 +359,45 @@ class ComponentSearchIndex:
             FROM components
             WHERE lib_id = ?
         """
-        
+
         with sqlite3.connect(str(self.db_path)) as conn:
             conn.row_factory = sqlite3.Row
             result = conn.execute(sql, [lib_id]).fetchone()
             return dict(result) if result else None
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get search index statistics."""
         with sqlite3.connect(str(self.db_path)) as conn:
             total_components = conn.execute("SELECT COUNT(*) FROM components").fetchone()[0]
-            total_libraries = conn.execute("SELECT COUNT(DISTINCT library) FROM components").fetchone()[0]
-            
+            total_libraries = conn.execute(
+                "SELECT COUNT(DISTINCT library) FROM components"
+            ).fetchone()[0]
+
             # Get library breakdown
-            library_stats = conn.execute("""
+            library_stats = conn.execute(
+                """
                 SELECT library, COUNT(*) as count
                 FROM components
                 GROUP BY library
                 ORDER BY count DESC
                 LIMIT 10
-            """).fetchall()
-            
+            """
+            ).fetchall()
+
         return {
             "total_components": total_components,
             "total_libraries": total_libraries,
             "top_libraries": [{"library": lib, "count": count} for lib, count in library_stats],
             "database_path": str(self.db_path),
-            "database_size_mb": round(self.db_path.stat().st_size / (1024 * 1024), 2)
+            "database_size_mb": round(self.db_path.stat().st_size / (1024 * 1024), 2),
         }
-    
+
     def _categorize_component(self, symbol: SymbolDefinition) -> str:
         """Categorize a component based on its properties."""
         prefix = symbol.reference_prefix.upper()
         name_lower = symbol.name.lower()
         desc_lower = symbol.description.lower()
-        
+
         # Category mapping based on reference prefix and description
         if prefix == "R":
             return "resistor"
@@ -410,7 +445,7 @@ def get_search_index() -> ComponentSearchIndex:
 def ensure_index_built(rebuild: bool = False) -> int:
     """Ensure the search index is built and up-to-date."""
     index = get_search_index()
-    
+
     if rebuild or not index.db_path.exists():
         logger.info("Building component search index...")
         return index.rebuild_index()
@@ -418,4 +453,4 @@ def ensure_index_built(rebuild: bool = False) -> int:
         # Check if index needs updating based on symbol cache
         stats = index.get_stats()
         logger.info(f"Search index ready: {stats['total_components']} components")
-        return stats["total_components"]
+        return stats["total_components"]