kicad-sch-api 0.2.1__tar.gz → 0.2.2__tar.gz

{kicad_sch_api-0.2.1 → kicad_sch_api-0.2.2}/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2025-01-20
+
+### Added
+- **Professional PyPI Release**: First official release to Python Package Index
+- **Enhanced Bounding Box Visualization**: 
+  - Colored rectangle support with all KiCAD stroke types
+  - Support for solid, dash, dot, dash_dot, dash_dot_dot line styles
+  - Component bounding box visualization with color customization
+- **Improved Manhattan Routing**:
+  - Enhanced obstacle avoidance algorithms
+  - Perfect KiCAD grid alignment (1.27mm grid)
+  - Multiple routing strategies and clearance options
+- **Code Quality Improvements**:
+  - Formatted with black for consistent style
+  - Import sorting with isort
+  - Enhanced type checking coverage
+- **Comprehensive Testing**:
+  - 71 passing tests with 6 intentionally skipped
+  - Enhanced test coverage for new features
+  - Format preservation validation
+
+### Enhanced
+- **Exact Format Preservation**: Improved KiCAD format compatibility
+- **Parser & Formatter**: Enhanced S-expression handling
+- **Performance**: Optimized for professional use cases
+
+### Technical
+- **Dependencies**: Updated build system and packaging
+- **Documentation**: Enhanced API documentation
+- **CI/CD**: Professional package validation and testing
+
 ## [0.3.1] - 2025-01-20
 
 ### Added

{kicad_sch_api-0.2.1/kicad_sch_api.egg-info → kicad_sch_api-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.2.1
+Version: 0.2.2
 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.2.1 → kicad_sch_api-0.2.2}/kicad_sch_api/core/formatter.py

@@ -55,7 +55,7 @@ class ExactFormatter:
         self.rules["generator"] = FormatRule(inline=True, quote_indices={1})
         self.rules["generator_version"] = FormatRule(inline=True, quote_indices={1})
         self.rules["uuid"] = FormatRule(inline=True, quote_indices={1})
-        self.rules["paper"] = FormatRule(inline=True, quote_indices={1})
+        self.rules["paper"] = FormatRule(inline=True)  # No quotes for paper size (A4, A3, etc.)
 
         # Title block
         self.rules["title_block"] = FormatRule(inline=False)
@@ -112,6 +112,12 @@ class ExactFormatter:
         self.rules["junction"] = FormatRule(inline=False)
         self.rules["diameter"] = FormatRule(inline=True)
 
+        # Graphical elements
+        self.rules["rectangle"] = FormatRule(inline=False)
+        self.rules["start"] = FormatRule(inline=True)
+        self.rules["end"] = FormatRule(inline=True)
+        self.rules["fill"] = FormatRule(inline=False)
+
         # Labels
         self.rules["label"] = FormatRule(inline=False, quote_indices={1})
         self.rules["global_label"] = FormatRule(inline=False, quote_indices={1})

{kicad_sch_api-0.2.1 → kicad_sch_api-0.2.2}/kicad_sch_api/core/parser.py

@@ -187,6 +187,7 @@ class SExpressionParser:
             "wires": [],
             "junctions": [],
             "labels": [],
+            "rectangles": [],
             "nets": [],
             "lib_symbols": {},
             "sheet_instances": [],
@@ -232,6 +233,10 @@ class SExpressionParser:
                 label = self._parse_label(item)
                 if label:
                     schematic_data["labels"].append(label)
+            elif element_type == "rectangle":
+                rectangle = self._parse_rectangle(item)
+                if rectangle:
+                    schematic_data["rectangles"].append(rectangle)
             elif element_type == "lib_symbols":
                 schematic_data["lib_symbols"] = self._parse_lib_symbols(item)
             elif element_type == "sheet_instances":
@@ -304,10 +309,14 @@ class SExpressionParser:
         for text_box in schematic_data.get("text_boxes", []):
             sexp_data.append(self._text_box_to_sexp(text_box))
 
-        # Add graphics (rectangles, etc.)
+        # Add graphics (rectangles from schematic.draw_bounding_box)
         for graphic in schematic_data.get("graphics", []):
             sexp_data.append(self._graphic_to_sexp(graphic))
 
+        # Add rectangles (rectangles from add_rectangle API)
+        for rectangle in schematic_data.get("rectangles", []):
+            sexp_data.append(self._rectangle_to_sexp(rectangle))
+
         # Add sheet_instances (required by KiCAD)
         sheet_instances = schematic_data.get("sheet_instances", [])
         if sheet_instances:
@@ -425,6 +434,37 @@ class SExpressionParser:
         # Implementation for label parsing
         return {}
 
+    def _parse_rectangle(self, item: List[Any]) -> Optional[Dict[str, Any]]:
+        """Parse a rectangle graphical element."""
+        rectangle = {}
+
+        for elem in item[1:]:
+            if not isinstance(elem, list):
+                continue
+
+            elem_type = str(elem[0])
+
+            if elem_type == "start" and len(elem) >= 3:
+                rectangle["start"] = {"x": float(elem[1]), "y": float(elem[2])}
+            elif elem_type == "end" and len(elem) >= 3:
+                rectangle["end"] = {"x": float(elem[1]), "y": float(elem[2])}
+            elif elem_type == "stroke":
+                for stroke_elem in elem[1:]:
+                    if isinstance(stroke_elem, list):
+                        stroke_type = str(stroke_elem[0])
+                        if stroke_type == "width" and len(stroke_elem) >= 2:
+                            rectangle["stroke_width"] = float(stroke_elem[1])
+                        elif stroke_type == "type" and len(stroke_elem) >= 2:
+                            rectangle["stroke_type"] = str(stroke_elem[1])
+            elif elem_type == "fill":
+                for fill_elem in elem[1:]:
+                    if isinstance(fill_elem, list) and str(fill_elem[0]) == "type":
+                        rectangle["fill_type"] = str(fill_elem[1]) if len(fill_elem) >= 2 else "none"
+            elif elem_type == "uuid" and len(elem) >= 2:
+                rectangle["uuid"] = str(elem[1])
+
+        return rectangle if rectangle else None
+
     def _parse_lib_symbols(self, item: List[Any]) -> Dict[str, Any]:
         """Parse lib_symbols section."""
         # Implementation for lib_symbols parsing
@@ -529,14 +569,28 @@ class SExpressionParser:
         # Add instances section (required by KiCAD)
         from .config import config
 
-        project_name = getattr(self, "project_name", config.defaults.project_name)
-        root_uuid = schematic_uuid or symbol_data.get("root_uuid", str(uuid.uuid4()))
-        logger.debug(
-            f"🔧 Using UUID {root_uuid} for component {symbol_data.get('reference', 'unknown')}"
-        )
-        logger.debug(
-            f"🔧 Component properties keys: {list(symbol_data.get('properties', {}).keys())}"
-        )
+        # Get project name from config or properties
+        project_name = symbol_data.get("properties", {}).get("project_name")
+        if not project_name:
+            project_name = getattr(self, "project_name", config.defaults.project_name)
+
+        # CRITICAL FIX: Use the FULL hierarchy_path from properties if available
+        # For hierarchical schematics, this contains the complete path: /root_uuid/sheet_symbol_uuid/...
+        # This ensures KiCad can properly annotate components in sub-sheets
+        hierarchy_path = symbol_data.get("properties", {}).get("hierarchy_path")
+        if hierarchy_path:
+            # Use the full hierarchical path (includes root + all sheet symbols)
+            instance_path = hierarchy_path
+            logger.debug(f"🔧 Using FULL hierarchy_path: {instance_path} for component {symbol_data.get('reference', 'unknown')}")
+        else:
+            # Fallback: use root_uuid or schematic_uuid for flat designs
+            root_uuid = symbol_data.get("properties", {}).get("root_uuid") or schematic_uuid or str(uuid.uuid4())
+            instance_path = f"/{root_uuid}"
+            logger.debug(f"🔧 Using root UUID path: {instance_path} for component {symbol_data.get('reference', 'unknown')}")
+
+        logger.debug(f"🔧 Component properties keys: {list(symbol_data.get('properties', {}).keys())}")
+        logger.debug(f"🔧 Using project name: '{project_name}'")
+
         sexp.append(
             [
                 sexpdata.Symbol("instances"),
@@ -545,7 +599,7 @@ class SExpressionParser:
                     project_name,
                     [
                         sexpdata.Symbol("path"),
-                        f"/{root_uuid}",
+                        instance_path,
                         [sexpdata.Symbol("reference"), symbol_data.get("reference", "U?")],
                         [sexpdata.Symbol("unit"), symbol_data.get("unit", 1)],
                     ],
@@ -772,7 +826,10 @@ class SExpressionParser:
         effects = [sexpdata.Symbol("effects")]
         font = [sexpdata.Symbol("font"), [sexpdata.Symbol("size"), size, size]]
         effects.append(font)
-        effects.append([sexpdata.Symbol("justify"), sexpdata.Symbol("left")])
+
+        # Use justification from data if provided, otherwise default to "left"
+        justify = hlabel_data.get("justify", "left")
+        effects.append([sexpdata.Symbol("justify"), sexpdata.Symbol(justify)])
         sexp.append(effects)
 
         # Add UUID
@@ -1034,6 +1091,40 @@ class SExpressionParser:
 
         return sexp
 
+    def _rectangle_to_sexp(self, rectangle_data: Dict[str, Any]) -> List[Any]:
+        """Convert rectangle element to S-expression."""
+        sexp = [sexpdata.Symbol("rectangle")]
+
+        # Add start point
+        start = rectangle_data["start"]
+        start_x, start_y = start["x"], start["y"]
+        sexp.append([sexpdata.Symbol("start"), start_x, start_y])
+
+        # Add end point
+        end = rectangle_data["end"]
+        end_x, end_y = end["x"], end["y"]
+        sexp.append([sexpdata.Symbol("end"), end_x, end_y])
+
+        # Add stroke
+        stroke_width = rectangle_data.get("stroke_width", 0)
+        stroke_type = rectangle_data.get("stroke_type", "default")
+        stroke_sexp = [sexpdata.Symbol("stroke")]
+        stroke_sexp.append([sexpdata.Symbol("width"), stroke_width])
+        stroke_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(stroke_type)])
+        sexp.append(stroke_sexp)
+
+        # Add fill
+        fill_type = rectangle_data.get("fill_type", "none")
+        fill_sexp = [sexpdata.Symbol("fill")]
+        fill_sexp.append([sexpdata.Symbol("type"), sexpdata.Symbol(fill_type)])
+        sexp.append(fill_sexp)
+
+        # Add UUID
+        if "uuid" in rectangle_data:
+            sexp.append([sexpdata.Symbol("uuid"), rectangle_data["uuid"]])
+
+        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.2.1 → kicad_sch_api-0.2.2}/kicad_sch_api/core/schematic.py

@@ -1138,6 +1138,59 @@ class Schematic:
         logger.debug(f"Added text box: '{text}' at {position} size {size}")
         return text_box.uuid
 
+    def add_rectangle(
+        self,
+        start: Union[Point, Tuple[float, float]],
+        end: Union[Point, Tuple[float, float]],
+        stroke_width: float = 0.0,
+        stroke_type: str = "default",
+        fill_type: str = "none"
+    ) -> str:
+        """
+        Add a graphical rectangle element.
+
+        Args:
+            start: Rectangle start point (top-left)
+            end: Rectangle end point (bottom-right)
+            stroke_width: Border line width
+            stroke_type: Border line type (default, solid, dash, dot, etc.)
+            fill_type: Fill type (none, solid, etc.)
+
+        Returns:
+            UUID of created rectangle element
+        """
+        if isinstance(start, tuple):
+            start = Point(start[0], start[1])
+        if isinstance(end, tuple):
+            end = Point(end[0], end[1])
+
+        from .types import SchematicRectangle
+
+        rectangle = SchematicRectangle(
+            uuid=str(uuid.uuid4()),
+            start=start,
+            end=end,
+            stroke_width=stroke_width,
+            stroke_type=stroke_type,
+            fill_type=fill_type
+        )
+
+        if "rectangles" not in self._data:
+            self._data["rectangles"] = []
+
+        self._data["rectangles"].append({
+            "uuid": rectangle.uuid,
+            "start": {"x": rectangle.start.x, "y": rectangle.start.y},
+            "end": {"x": rectangle.end.x, "y": rectangle.end.y},
+            "stroke_width": rectangle.stroke_width,
+            "stroke_type": rectangle.stroke_type,
+            "fill_type": rectangle.fill_type
+        })
+        self._modified = True
+
+        logger.debug(f"Added rectangle: {start} to {end}")
+        return rectangle.uuid
+
     def set_title_block(
         self,
         title: str = "",

{kicad_sch_api-0.2.1 → kicad_sch_api-0.2.2}/kicad_sch_api/core/types.py

@@ -338,6 +338,40 @@ class TextBox:
             self.uuid = str(uuid4())
 
 
+@dataclass
+class SchematicRectangle:
+    """Graphical rectangle element in schematic."""
+
+    uuid: str
+    start: Point
+    end: Point
+    stroke_width: float = 0.0
+    stroke_type: str = "default"
+    fill_type: str = "none"
+
+    def __post_init__(self):
+        if not self.uuid:
+            self.uuid = str(uuid4())
+
+    @property
+    def width(self) -> float:
+        """Rectangle width."""
+        return abs(self.end.x - self.start.x)
+
+    @property
+    def height(self) -> float:
+        """Rectangle height."""
+        return abs(self.end.y - self.start.y)
+
+    @property
+    def center(self) -> Point:
+        """Rectangle center point."""
+        return Point(
+            (self.start.x + self.end.x) / 2,
+            (self.start.y + self.end.y) / 2
+        )
+
+
 @dataclass
 class Net:
     """Electrical net connecting components."""
@@ -434,6 +468,7 @@ class Schematic:
     labels: List[Label] = field(default_factory=list)
     nets: List[Net] = field(default_factory=list)
     sheets: List[Sheet] = field(default_factory=list)
+    rectangles: List[SchematicRectangle] = field(default_factory=list)
     lib_symbols: Dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self):

{kicad_sch_api-0.2.1 → kicad_sch_api-0.2.2/kicad_sch_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kicad-sch-api
-Version: 0.2.1
+Version: 0.2.2
 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.2.1 → kicad_sch_api-0.2.2}/kicad_sch_api.egg-info/SOURCES.txt

@@ -53,8 +53,11 @@ tests/test_component_removal.py
 tests/test_element_removal.py
 tests/test_grid_snapping.py
 tests/test_manhattan_routing.py
+tests/test_parse_reference_rectangles.py
 tests/test_pin_positioning.py
 tests/test_pin_to_pin_wiring.py
+tests/test_rectangle.py
+tests/test_rectangle_roundtrip.py
 tests/test_removal_against_references.py
 tests/reference_tests/reference_kicad_projects/README.md
 tests/reference_tests/reference_kicad_projects/blank_schematic/blank_schematic.kicad_pro

{kicad_sch_api-0.2.1 → kicad_sch_api-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kicad-sch-api"
-version = "0.2.1"
+version = "0.2.2"
 description = "Professional KiCAD schematic manipulation library with exact format preservation"
 readme = "README.md"
 license = "MIT"

kicad_sch_api-0.2.2/tests/test_parse_reference_rectangles.py

@@ -0,0 +1,48 @@
+"""
+Test parsing rectangles from the reference RP2040 schematic.
+"""
+
+import pytest
+from kicad_sch_api import load_schematic
+
+
+REFERENCE_SCHEMATIC = "/Users/shanemattner/Desktop/circuit-synth-examples/pcbs/rp2040-minimal/RP2040_Minimal/RP2040_Minimal.kicad_sch"
+
+
+def test_parse_reference_schematic_rectangles():
+    """Test that we can parse rectangles from the reference schematic."""
+    try:
+        sch = load_schematic(REFERENCE_SCHEMATIC)
+
+        # The reference schematic should have rectangles (bounding boxes)
+        assert "rectangles" in sch._data
+        rectangles = sch._data["rectangles"]
+
+        # Should have at least one rectangle
+        assert len(rectangles) > 0, "Expected to find rectangles in reference schematic"
+
+        # Verify rectangle structure
+        rect = rectangles[0]
+        assert "start" in rect
+        assert "end" in rect
+        assert "x" in rect["start"]
+        assert "y" in rect["start"]
+        assert "x" in rect["end"]
+        assert "y" in rect["end"]
+        assert "uuid" in rect
+
+        # Verify stroke and fill
+        assert "stroke_width" in rect
+        assert "stroke_type" in rect
+        assert "fill_type" in rect
+
+        print(f"Successfully parsed {len(rectangles)} rectangles from reference schematic")
+        print(f"First rectangle: start=({rect['start']['x']}, {rect['start']['y']}), "
+              f"end=({rect['end']['x']}, {rect['end']['y']})")
+
+    except FileNotFoundError:
+        pytest.skip(f"Reference schematic not found: {REFERENCE_SCHEMATIC}")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "-s"])

kicad_sch_api-0.2.2/tests/test_rectangle.py

@@ -0,0 +1,88 @@
+"""
+Test rectangle functionality in kicad-sch-api.
+"""
+
+import pytest
+from kicad_sch_api.core.schematic import Schematic
+from kicad_sch_api.core.types import Point
+
+
+def test_add_rectangle():
+    """Test adding a rectangle to a schematic."""
+    # Create a new schematic
+    sch = Schematic()
+
+    # Add a rectangle
+    rect_uuid = sch.add_rectangle(
+        start=(10.0, 20.0),
+        end=(50.0, 60.0),
+        stroke_width=0.127,
+        stroke_type="solid",
+        fill_type="none"
+    )
+
+    # Verify UUID was returned
+    assert rect_uuid is not None
+    assert isinstance(rect_uuid, str)
+
+    # Verify rectangle was added to internal data
+    assert "rectangles" in sch._data
+    assert len(sch._data["rectangles"]) == 1
+
+    # Verify rectangle properties
+    rect = sch._data["rectangles"][0]
+    assert rect["uuid"] == rect_uuid
+    assert rect["start"]["x"] == 10.0
+    assert rect["start"]["y"] == 20.0
+    assert rect["end"]["x"] == 50.0
+    assert rect["end"]["y"] == 60.0
+    assert rect["stroke_width"] == 0.127
+    assert rect["stroke_type"] == "solid"
+    assert rect["fill_type"] == "none"
+
+
+def test_add_rectangle_with_point_objects():
+    """Test adding rectangle using Point objects."""
+    sch = Schematic()
+
+    start = Point(100.0, 200.0)
+    end = Point(150.0, 250.0)
+
+    rect_uuid = sch.add_rectangle(
+        start=start,
+        end=end,
+        stroke_width=0.254
+    )
+
+    assert rect_uuid is not None
+    rect = sch._data["rectangles"][0]
+    assert rect["start"]["x"] == 100.0
+    assert rect["start"]["y"] == 200.0
+
+
+def test_add_multiple_rectangles():
+    """Test adding multiple rectangles."""
+    sch = Schematic()
+
+    rect1_uuid = sch.add_rectangle((0, 0), (10, 10))
+    rect2_uuid = sch.add_rectangle((20, 20), (30, 30))
+    rect3_uuid = sch.add_rectangle((40, 40), (50, 50))
+
+    assert len(sch._data["rectangles"]) == 3
+    assert rect1_uuid != rect2_uuid != rect3_uuid
+
+
+def test_rectangle_default_values():
+    """Test rectangle default parameter values."""
+    sch = Schematic()
+
+    rect_uuid = sch.add_rectangle((0, 0), (10, 10))
+
+    rect = sch._data["rectangles"][0]
+    assert rect["stroke_width"] == 0.0
+    assert rect["stroke_type"] == "default"
+    assert rect["fill_type"] == "none"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

kicad_sch_api-0.2.2/tests/test_rectangle_roundtrip.py

@@ -0,0 +1,111 @@
+"""
+Test rectangle round-trip: create, save, load, verify.
+"""
+
+import os
+import tempfile
+import pytest
+from kicad_sch_api import create_schematic, load_schematic
+
+
+def test_rectangle_roundtrip():
+    """Test creating, saving, and loading a schematic with rectangles."""
+    # Create a schematic with rectangles
+    sch = create_schematic("Rectangle Test")
+
+    # Add multiple rectangles
+    rect1_uuid = sch.add_rectangle(
+        start=(10.0, 20.0),
+        end=(50.0, 60.0),
+        stroke_width=0.127,
+        stroke_type="solid",
+        fill_type="none"
+    )
+
+    rect2_uuid = sch.add_rectangle(
+        start=(100.0, 100.0),
+        end=(200.0, 150.0),
+        stroke_width=0.254,
+        stroke_type="default",
+        fill_type="none"
+    )
+
+    # Save to temporary file
+    with tempfile.NamedTemporaryFile(suffix=".kicad_sch", delete=False, mode='w') as f:
+        temp_path = f.name
+
+    try:
+        sch.save(temp_path)
+
+        # Load the schematic back
+        sch_loaded = load_schematic(temp_path)
+
+        # Verify rectangles were preserved
+        assert "rectangles" in sch_loaded._data
+        assert len(sch_loaded._data["rectangles"]) == 2
+
+        # Verify first rectangle
+        rect1 = sch_loaded._data["rectangles"][0]
+        assert rect1["uuid"] == rect1_uuid
+        assert rect1["start"]["x"] == 10.0
+        assert rect1["start"]["y"] == 20.0
+        assert rect1["end"]["x"] == 50.0
+        assert rect1["end"]["y"] == 60.0
+        assert rect1["stroke_width"] == 0.127
+        assert rect1["stroke_type"] == "solid"
+
+        # Verify second rectangle
+        rect2 = sch_loaded._data["rectangles"][1]
+        assert rect2["uuid"] == rect2_uuid
+        assert rect2["start"]["x"] == 100.0
+        assert rect2["start"]["y"] == 100.0
+        assert rect2["stroke_width"] == 0.254
+
+    finally:
+        # Cleanup
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+
+def test_rectangle_format_preservation():
+    """Test that rectangle S-expression format matches KiCAD."""
+    sch = create_schematic("Format Test")
+
+    # Add rectangle with specific parameters
+    sch.add_rectangle(
+        start=(91.821, 32.211),
+        end=(155.829, 148.049),
+        stroke_width=0.127,
+        stroke_type="solid",
+        fill_type="none"
+    )
+
+    # Save to string
+    with tempfile.NamedTemporaryFile(suffix=".kicad_sch", delete=False, mode='w') as f:
+        temp_path = f.name
+
+    try:
+        sch.save(temp_path)
+
+        # Read file content
+        with open(temp_path, 'r') as f:
+            content = f.read()
+
+        # Verify S-expression structure
+        assert "(rectangle" in content
+        assert "(start 91.821 32.211)" in content
+        assert "(end 155.829 148.049)" in content
+        assert "(stroke" in content
+        assert "(width 0.127)" in content
+        assert "(type solid)" in content
+        assert "(fill" in content
+        assert "(type none)" in content
+        assert "(uuid" in content
+
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])