b3dkit 0.1.0__tar.gz → 0.1.1__tar.gz

{b3dkit-0.1.0 → b3dkit-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3dkit
-Version: 0.1.0
+Version: 0.1.1
 Summary: build123d libraries and utilities
 Project-URL: Homepage, https://github.com/x0pherl/b3dkit
 Project-URL: Issues, https://github.com/x0pherl/b3dkit/issues
@@ -14,14 +14,17 @@ Requires-Python: >=3.8
 Requires-Dist: build123d>=0.0.1
 Requires-Dist: ocp-vscode
 Provides-Extra: dev
-Requires-Dist: build; extra == 'dev'
-Requires-Dist: hatchling; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: markdown-include; extra == 'docs'
 Requires-Dist: mkdocs; extra == 'docs'
 Requires-Dist: mkdocs-material; extra == 'docs'
+Provides-Extra: maintain
+Requires-Dist: build; extra == 'maintain'
+Requires-Dist: hatch-vcs; extra == 'maintain'
+Requires-Dist: hatchling; extra == 'maintain'
+Requires-Dist: twine; extra == 'maintain'
 Description-Content-Type: text/markdown
 
 # b3dkit Overview

{b3dkit-0.1.0 → b3dkit-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "b3dkit"
-version = "0.1.0"
+version = "0.1.1"
 authors = [
   { name="x0pherl"},
 ]
@@ -21,9 +21,13 @@ dependencies = [
 dev = [
   "pytest",
   "pytest-cov",
+  ]
+maintain =[
+  "twine",
+  "hatch-vcs",
   "hatchling",
   "build",
-  ]
+]
 docs = [
   "mkdocs",
   "mkdocs-material",

{b3dkit-0.1.0 → b3dkit-0.1.1}/src/b3dkit/__init__.py

@@ -1,5 +1,6 @@
 from b3dkit.basic_shapes import *
 from b3dkit.ball_socket import *
+from b3dkit.bolt_fittings import *
 from b3dkit.click_fit import *
 from b3dkit.dovetail import *
 from b3dkit.hexwall import *

{b3dkit-0.1.0 → b3dkit-0.1.1}/src/b3dkit/bolt_fittings.py

@@ -85,12 +85,12 @@ class TeardropBoltCutSinkhole(BasePartObject):
                     sinkhole.faces().sort_by(Axis.Z)[-1],
                     amount=extension_distance,
                 )
-        final_template = anti_chamfer(
-            sinkhole.part.faces().sort_by(Axis.Z)[-1],
-            chamfer_radius,
-        )
+            anti_chamfer(
+                sinkhole.part.faces().sort_by(Axis.Z)[-1],
+                chamfer_radius,
+            )
         super().__init__(
-            part=final_template,
+            part=sinkhole.part,
             rotation=rotation,
             align=tuplify(align, 3),
             mode=mode,
@@ -132,7 +132,7 @@ class BoltCutSinkhole(BasePartObject):
             - mode: the mode to use when adding the sinkhole
         Returns:
             - Part: A cylindrical bolt hole part with countersink"""
-        pt = TeardropBoltCutSinkhole(
+        sinkhole = TeardropBoltCutSinkhole(
             shaft_radius=shaft_radius,
             shaft_depth=shaft_depth,
             head_radius=head_radius,
@@ -140,8 +140,17 @@ class BoltCutSinkhole(BasePartObject):
             chamfer_radius=chamfer_radius,
             extension_distance=extension_distance,
             teardrop_ratio=1.0,
+            rotation=rotation,
+            align=tuplify(align, 3),
+            mode=mode,
+        )
+
+        super().__init__(
+            part=sinkhole,
+            rotation=rotation,
+            align=tuplify(align, 3),
+            mode=mode,
         )
-        super().__init__(part=pt, rotation=rotation, align=tuplify(align, 3), mode=mode)
 
 
 class SquareNutSinkhole(BasePartObject):
@@ -348,4 +357,7 @@ class HeatsinkCut(BasePartObject):
 
 
 if __name__ == "__main__":
-    show(SquareNutSinkhole(), reset_camera=Camera.KEEP)
+    with BuildPart() as tst:
+        Box(20, 20, 20)
+        BoltCutSinkhole(mode=Mode.SUBTRACT)
+    show(tst.part, reset_camera=Camera.KEEP)

{b3dkit-0.1.0 → b3dkit-0.1.1}/src/b3dkit/hexwall.py

@@ -90,10 +90,10 @@ class HexWall(BasePartObject):
 if __name__ == "__main__":
     show(
         HexWall(
-            width=200,
-            length=400,
+            width=20,
+            length=40,
             height=2,
-            apothem=10,
+            apothem=9,
             wall_thickness=2,
             inverse=True,
             align=(Align.CENTER, Align.CENTER, Align.MIN),

b3dkit-0.1.1/tests/test_antichamfer.py

@@ -0,0 +1,147 @@
+import pytest
+from unittest.mock import patch
+from importlib.machinery import SourceFileLoader
+from importlib.util import module_from_spec, spec_from_loader
+from math import atan, degrees
+from build123d import (
+    Align,
+    Axis,
+    Box,
+    BuildPart,
+    Cylinder,
+    Face,
+    Part,
+    Plane,
+)
+from b3dkit.antichamfer import anti_chamfer
+
+
+class TestAntiChamfer:
+    def test_anti_chamfer_in_build_context(self):
+        """Test anti_chamfer within a BuildPart context"""
+
+        with BuildPart() as bkt:
+            Box(
+                10,
+                10,
+                10,
+            )
+            anti_chamfer(bkt.faces().filter_by(Axis.Z), 2, 1)
+
+        assert bkt.part.is_valid
+        original_volume = 10 * 10 * 10
+        assert bkt.part.volume > original_volume
+
+    def test_anti_chamfer_single_face(self):
+        """Test anti_chamfer with a single face"""
+        with BuildPart() as bp:
+            Box(10, 10, 10)
+        original_part = bp.part
+
+        top_face = original_part.faces().filter_by(Axis.Z)[-1]
+
+        ac = anti_chamfer(top_face, 2.0, 1.0)
+
+        assert ac.is_valid
+        assert ac.volume > original_part.volume
+
+    def test_anti_chamfer_empty_face(self):
+        """Test anti_chamfer with an empty face list"""
+        with pytest.raises(ValueError):
+            anti_chamfer([], 2.0, 1.0)
+
+    def test_anti_chamfer_float_face(self):
+        """Test anti_chamfer with a non-Face input"""
+        with pytest.raises(ValueError):
+            anti_chamfer([3.2], 2.0, 1.0)
+
+    def test_contextless_face(self):
+        """Test anti_chamfer with a Face that has no context Part"""
+        test_face = Face(Plane.XY)
+        with pytest.raises(ValueError):
+            anti_chamfer(test_face, 1.0, 1.0)
+
+    def test_anti_chamfer_multiple_faces(self):
+        """Test anti_chamfer with multiple faces (iterable)"""
+        with BuildPart() as bp:
+            Box(10, 10, 10)
+        original_part = bp.part
+
+        ac = anti_chamfer(original_part.faces().filter_by(Axis.Z), 1.5, 1.0)
+        assert ac.is_valid
+        assert ac.volume > original_part.volume
+
+    def test_anti_chamfer_length2_none_default(self):
+        """Test anti_chamfer with length2=None (should default to length)"""
+        with BuildPart() as bp:
+            Box(10, 10, 10)
+        original_part = bp.part
+
+        top_face = original_part.faces().filter_by(Axis.Z)[-1]
+
+        ac1 = anti_chamfer(top_face, 2.0, None)
+        ac2 = anti_chamfer(top_face, 2.0, 2.0)
+
+        assert pytest.approx(0) == abs(ac1.volume - ac2.volume)
+
+    def test_anti_chamfer_different_length_values(self):
+        """Test anti_chamfer with different length and length2 values"""
+        with BuildPart() as bp:
+            Box(10, 10, 10)
+        original_part = bp.part
+
+        top_face = original_part.faces().filter_by(Axis.Z)[-1]
+
+        ac1 = anti_chamfer(top_face, 1.0, 0.5)
+        ac2 = anti_chamfer(top_face, 2.0, 1.0)
+        ac3 = anti_chamfer(top_face, 1.0, 2.0)
+
+        assert ac1.is_valid
+        assert ac2.is_valid
+        assert ac3.is_valid
+
+        assert ac1.volume != ac2.volume != ac3.volume
+
+    def test_anti_chamfer_with_cylinder(self):
+        """Test anti_chamfer works with a round face"""
+        with BuildPart() as bp:
+            Cylinder(5, 10)
+        original_part = bp.part
+
+        ac_part = anti_chamfer(bp.part.faces().filter_by(Axis.Z)[-1], 1.0, 0.8)
+
+        assert ac_part.is_valid
+        assert ac_part.volume > original_part.volume
+
+    def test_anti_chamfer_negative_length_values(self):
+        """Test anti_chamfer with negative length values"""
+        with BuildPart() as bp:
+            Box(10, 10, 10)
+
+        ac_part = anti_chamfer(bp.part.faces().filter_by(Axis.Z)[-1], -1.0, -0.5)
+        assert ac_part.is_valid
+
+    def test_anti_chamfer_zero_length_values(self):
+        """Test anti_chamfer with negative length values"""
+        with BuildPart() as bp:
+            Box(10, 10, 10)
+
+        ac1 = anti_chamfer(bp.part.faces().filter_by(Axis.Z)[-1], 1, 0)
+        ac2 = anti_chamfer(bp.part.faces().filter_by(Axis.Z)[-1], 0, 1)
+
+        assert ac1.is_valid
+        assert ac2.is_valid
+        assert bp.part.volume == ac1.volume == ac2.volume
+
+    def test_direct_run(self):
+
+        with (
+            patch("build123d.export_stl"),
+            patch("pathlib.Path.mkdir"),
+            patch("pathlib.Path.exists"),
+            patch("pathlib.Path.is_dir"),
+            patch("ocp_vscode.show"),
+            patch("ocp_vscode.save_screenshot"),
+        ):
+            loader = SourceFileLoader("__main__", "src/b3dkit/antichamfer.py")
+            loader.exec_module(module_from_spec(spec_from_loader(loader.name, loader)))

b3dkit-0.1.1/tests/test_ball_socket.py

@@ -0,0 +1,105 @@
+from importlib.machinery import SourceFileLoader
+from importlib.util import module_from_spec, spec_from_loader
+from unittest.mock import patch
+import math
+import pytest
+from build123d import Part
+
+from b3dkit.ball_socket import BallMount, BallSocket
+
+
+# ---------- Helpers ----------
+def expected_socket_height(r: float, w: float) -> float:
+    # Matches current implementation: cylinder height = ball_radius + wall_thickness * 2.5
+    return r + w * 2.5
+
+
+def expected_socket_diameter(r: float, w: float) -> float:
+    return 2 * (r + w)
+
+
+# ---------- Ball Mount Tests ----------
+class TestBallMount:
+    def test_ball_mount_basic(self):
+        mount = BallMount(10.0)
+        assert isinstance(mount, Part)
+        assert mount.is_valid
+        bbox = mount.bounding_box()
+        assert bbox.size.X == pytest.approx(20.0, abs=0.1)
+        assert bbox.size.Y == pytest.approx(20.0, abs=0.1)
+        # Height = 3.5 * radius (shaft from 0 to 2.25R, sphere center at 2.5R -> top 3.5R)
+        assert bbox.size.Z == pytest.approx(35.0, abs=0.5)
+
+
+class TestBallSocket:
+    def test_ball_socket_basic(self):
+        r = 10.0
+        w = 2.0
+        socket = BallSocket(r)
+        assert isinstance(socket, Part)
+        assert socket.is_valid
+        assert socket.label == "Ball Socket"
+
+    @pytest.mark.parametrize("r,w", [(3, 2), (5, 1), (10, 2), (20, 4), (12.5, 3.5)])
+    def test_ball_socket_param_dimensions(self, r, w):
+        socket = BallSocket(r, wall_thickness=w)
+        assert socket.is_valid
+        bbox = socket.bounding_box()
+
+    def test_ball_socket_custom_wall_thickness(self):
+        r, w = 10.0, 3.0
+        socket = BallSocket(r, wall_thickness=w)
+
+    def test_ball_socket_tolerance_does_not_change_outer_size(self):
+        r, w = 10.0, 2.0
+        base_bbox = BallSocket(r).bounding_box()
+        bbox = BallSocket(r, tolerance=0.2).bounding_box()
+        assert bbox.size.X == pytest.approx(base_bbox.size.X, abs=0.05)
+        assert bbox.size.Z == pytest.approx(base_bbox.size.Z, abs=0.05)
+
+    def test_ball_socket_wall_thickness_volume_growth(self):
+        r = 10.0
+        thin = BallSocket(r, wall_thickness=1.0)
+        thick = BallSocket(r, wall_thickness=5.0)
+        assert thin.volume < thick.volume
+
+    def test_ball_socket_centered(self):
+        socket = BallSocket(10.0)
+        bbox = socket.bounding_box()
+        assert abs(bbox.center().X) < 0.01
+        assert abs(bbox.center().Y) < 0.01
+        assert bbox.min.Z == pytest.approx(0.0, abs=0.01)
+
+    def test_ball_socket_small_radius(self):
+        r, w = 3.0, 2.0
+        socket = BallSocket(r)
+        bbox = socket.bounding_box()
+        assert bbox.size.X == pytest.approx(expected_socket_diameter(r, w), abs=0.1)
+        assert bbox.size.Z == pytest.approx(expected_socket_height(r, w), abs=0.1)
+
+    def test_ball_socket_has_flex_cuts_volume_reduction(self):
+        r, w = 10.0, 2.0
+        socket = BallSocket(r)
+        assert socket.volume > 0
+        # Compare to solid cylinder of same outer size
+        solid_volume = math.pi * (r + w) ** 2 * expected_socket_height(r, w)
+        assert socket.volume < solid_volume * 0.9  # should be noticeably reduced
+
+
+# ---------- Edge / Extreme Cases ----------
+class TestEdgeCases:
+
+    def test_extreme_tolerance_values(self):
+        tight = BallSocket(10.0, tolerance=-0.1)
+        loose = BallSocket(10.0, tolerance=1.0)
+        assert tight.is_valid
+        assert loose.is_valid
+        assert loose.volume < BallSocket(10.0, tolerance=0.0).volume
+
+
+# ---------- Direct Run ----------
+class TestDirectRun:
+    def test_direct_run(self):
+        with patch("ocp_vscode.show"):
+            loader = SourceFileLoader("__main__", "src/b3dkit/ball_socket.py")
+            loader.exec_module(module_from_spec(spec_from_loader(loader.name, loader)))

b3dkit-0.1.1/tests/test_bolt_fittings.py

@@ -0,0 +1,215 @@
+"""
+Comprehensive tests for the bolt_fittings module.
+
+These tests cover all functions and their parameters to ensure:
+- Correct geometry creation
+- Parameter variations and edge cases
+- Return type validation
+- Dimensional accuracy
+- Mutation testing coverage
+"""
+
+from importlib.machinery import SourceFileLoader
+from importlib.util import module_from_spec, spec_from_loader
+from unittest.mock import patch
+import pytest
+from build123d import (
+    Align,
+    Axis,
+    BuildPart,
+    Part,
+)
+from b3dkit.bolt_fittings import (
+    TeardropBoltCutSinkhole,
+    ScrewCut,
+    NutCut,
+    BoltCutSinkhole,
+    HeatsinkCut,
+    SquareNutSinkhole,
+)
+
+
+class TestTeardropBoltCutSinkhole:
+    def test_teardrop_bolt_cut_default_parameters(self):
+        """Test teardrop bolt cut with default parameters"""
+        sinkhole = TeardropBoltCutSinkhole()
+
+        assert sinkhole.is_valid
+
+    def test_teardrop_bolt_cut_custom_shaft(self):
+        """Test teardrop bolt cut with custom shaft dimensions"""
+        sinkhole = TeardropBoltCutSinkhole(shaft_radius=2.0, shaft_depth=5.0)
+
+        assert sinkhole.is_valid
+
+    def test_teardrop_bolt_cut_custom_head(self):
+        """Test teardrop bolt cut with custom head dimensions"""
+        sinkhole = TeardropBoltCutSinkhole(head_radius=4.0, head_depth=3.0)
+
+        assert sinkhole.is_valid
+
+    def test_teardrop_bolt_cut_with_chamfer(self):
+        """Test teardrop bolt cut with various chamfer radii"""
+        sinkhole1 = TeardropBoltCutSinkhole(chamfer_radius=0.5)
+        sinkhole2 = TeardropBoltCutSinkhole(chamfer_radius=2.0)
+
+        assert sinkhole1.volume != sinkhole2.volume
+
+    def test_teardrop_bolt_cut_with_extension(self):
+        """Test teardrop bolt cut with extension distance"""
+        sinkhone_with = TeardropBoltCutSinkhole(extension_distance=50)
+        sinkhone_without = TeardropBoltCutSinkhole(extension_distance=0)
+
+        assert sinkhone_with.volume > sinkhone_without.volume
+
+    def test_teardrop_bolt_cut_zero_extension(self):
+        """Test teardrop bolt cut with zero extension (blind hole)"""
+        sinkhone = TeardropBoltCutSinkhole(extension_distance=0)
+
+        assert isinstance(sinkhone, Part)
+        assert sinkhone.volume > 0
+
+    def test_teardrop_bolt_cut_custom_teardrop_ratio(self):
+        """Test teardrop bolt cut with custom teardrop_ratio"""
+        boltcut1 = TeardropBoltCutSinkhole(teardrop_ratio=1.0)  # Cylindrical
+        boltcut2 = TeardropBoltCutSinkhole(teardrop_ratio=1.1)  # Default teardrop
+        boltcut3 = TeardropBoltCutSinkhole(
+            teardrop_ratio=1.2
+        )  # More pronounced teardrop
+
+        assert isinstance(boltcut1, Part)
+        assert isinstance(boltcut2, Part)
+        assert isinstance(boltcut3, Part)
+        # Larger ratios should produce larger volumes
+        assert boltcut1.volume < boltcut2.volume < boltcut3.volume
+
+
+class TestBoltCutSinkhole:
+    def test_bolt_cut_default_parameters(self):
+        """Test bolt cut with default parameters"""
+        boltcut = BoltCutSinkhole()
+
+        assert boltcut.is_valid
+
+    def test_bolt_cut_with_chamfer(self):
+        """Test bolt cut with various chamfer radii"""
+        boltcut1 = BoltCutSinkhole(chamfer_radius=0.5)
+        boltcut2 = BoltCutSinkhole(chamfer_radius=2.0)
+
+        assert isinstance(boltcut1, Part)
+        assert isinstance(boltcut2, Part)
+        # Different chamfer radii should produce different volumes
+        assert boltcut1.volume != boltcut2.volume
+
+    def test_bolt_cut_with_extension(self):
+        """Test bolt cut with extension distance"""
+        boltcut_with = BoltCutSinkhole(extension_distance=50)
+        boltcut_without = BoltCutSinkhole(extension_distance=0)
+
+        assert boltcut_with.volume > boltcut_without.volume
+
+    def test_bolt_cut_zero_extension(self):
+        """Test bolt cut with zero extension (blind hole)"""
+        boltcut = BoltCutSinkhole(extension_distance=0)
+
+        assert boltcut.is_valid
+
+    def test_bolt_cut_vs_teardrop(self):
+        """Test that bolt_cut and TeardropBoltCutSinkhole with default ratio produce different results"""
+        params = {
+            "shaft_radius": 1.65,
+            "shaft_depth": 2.0,
+            "head_radius": 3.1,
+            "head_depth": 5.0,
+            "chamfer_radius": 1.0,
+            "extension_distance": 10.0,
+        }
+
+        boltcut = BoltCutSinkhole(**params)
+        teardropcut = TeardropBoltCutSinkhole(**params)
+
+        # Teardrop with default ratio should have more volume than cylindrical
+        assert boltcut.is_valid
+        assert teardropcut.is_valid
+        assert teardropcut.volume > boltcut.volume
+
+    def test_bolt_cut_is_wrapper_for_teardrop(self):
+        """Test that BoltCutSinkhole is a wrapper for TeardropBoltCutSinkhole with ratio=1.0"""
+        params = {
+            "shaft_radius": 2.0,
+            "shaft_depth": 3.0,
+            "head_radius": 4.0,
+            "head_depth": 6.0,
+            "chamfer_radius": 1.5,
+            "extension_distance": 20.0,
+        }
+
+        boltcut = BoltCutSinkhole(**params)
+        teardropcut = TeardropBoltCutSinkhole(**params, teardrop_ratio=1.0)
+
+        # Should produce identical results
+        assert boltcut.is_valid
+        assert teardropcut.is_valid
+        assert abs(boltcut.volume - teardropcut.volume) < 1e-6
+
+
+class TestSquareNutSinkhole:
+    def test_square_nut_default_parameters(self):
+        """Test square nut sinkhole with default parameters"""
+        sinkhole = SquareNutSinkhole()
+
+        assert sinkhole.is_valid
+
+    def test_square_nut_with_extension(self):
+        """Test square nut sinkhole with bolt extension"""
+        sinkhole_with = SquareNutSinkhole(bolt_extension=5)
+        sinkhole_without = SquareNutSinkhole(bolt_extension=0)
+
+        assert sinkhole_with.volume > sinkhole_without.volume
+
+    def test_square_nut_zero_extension(self):
+        """Test square nut sinkhole with zero extension"""
+        sinkhole = SquareNutSinkhole(bolt_extension=0)
+
+        assert sinkhole.is_valid
+
+    def test_square_nut_different_nut_sizes(self):
+        """Test with different nut sizes"""
+        small_nut = SquareNutSinkhole(nut_legnth=4.0, nut_height=1.5)
+        large_nut = SquareNutSinkhole(nut_legnth=8.0, nut_height=3.0)
+
+        assert isinstance(small_nut, Part)
+        assert isinstance(large_nut, Part)
+        # Larger nut should have more volume
+        assert large_nut.volume > small_nut.volume
+
+
+class TestScrewCut:
+    def test_screw_cut(self):
+        screw = ScrewCut(5, 1, 2, 10, 10)
+        assert screw.is_valid
+        assert screw.bounding_box().size.X == pytest.approx(10)
+        assert screw.bounding_box().size.Y == pytest.approx(10)
+        assert screw.bounding_box().size.Z == pytest.approx(20)
+
+    def test_nut_cut(self):
+        nut = NutCut(5, 1, 2, 10)
+        assert nut.is_valid
+
+    def test_invalid_screw_cut(self):
+        with pytest.raises(ValueError):
+            ScrewCut(head_radius=5, shaft_radius=6)
+
+    def test_heatsink_cut(self):
+        heatsink = HeatsinkCut(10, 1, 5, 10)
+        assert heatsink.is_valid
+        assert heatsink.bounding_box().size.X == pytest.approx(20)
+        assert heatsink.bounding_box().size.Y == pytest.approx(20)
+        assert heatsink.bounding_box().size.Z == pytest.approx(11)
+
+
+class TestBareExecution:
+    def test_bare_execution(self):
+        with (patch("ocp_vscode.show"),):
+            loader = SourceFileLoader("__main__", "src/b3dkit/bolt_fittings.py")
+            loader.exec_module(module_from_spec(spec_from_loader(loader.name, loader)))

{b3dkit-0.1.0 → b3dkit-0.1.1}/tests/test_dovetail.py

@@ -14,7 +14,6 @@ from b3dkit.point import Point
 from b3dkit.dovetail import (
     DovetailPart,
     DovetailStyle,
-    dovetail_split_line,
     dovetail_subpart,
     snugtail_subpart_outline,
     dovetail_subpart_outline,
@@ -44,10 +43,6 @@ class TestDovetail:
                     test.part,
                     Point(5, 0),
                     Point(5, 0),
-                    # scarf_distance=0.5,
-                    section=DovetailPart.TAIL,
-                    # tilt=20,
-                    vertical_offset=-100,
                 ),
             )
 
@@ -60,9 +55,7 @@ class TestDovetail:
                     test.part,
                     Point(-5, 0),
                     Point(5, 0),
-                    # scarf_distance=0.5,
                     section=DovetailPart.TAIL,
-                    # tilt=20,
                     vertical_offset=100,
                 ),
             )
@@ -76,9 +69,7 @@ class TestDovetail:
                     test.part,
                     Point(-5, 0),
                     Point(5, 0),
-                    # scarf_distance=0.5,
                     section=DovetailPart.TAIL,
-                    # tilt=20,
                     vertical_offset=-100,
                 ),
             )
@@ -92,10 +83,8 @@ class TestDovetail:
                     test.part,
                     Point(-5, 0),
                     Point(5, 0),
-                    # scarf_distance=0.5,
                     section=DovetailPart.TAIL,
                     style=DovetailStyle.TRADITIONAL,
-                    # tilt=20,
                     vertical_offset=0.5,
                     click_fit_radius=0.5,
                 ),
@@ -173,10 +162,8 @@ class TestDovetail:
                     test.part,
                     Point(-5, 0),
                     Point(5, 0),
-                    # scarf_distance=0.5,
                     section=DovetailPart.TAIL,
                     style=DovetailStyle.SNUGTAIL,
-                    # tilt=20,
                     vertical_offset=0.5,
                     click_fit_radius=1,
                 ),
@@ -226,7 +213,6 @@ class TestDovetail:
                     Point(5, 0),
                     taper_angle=-1,
                     section=DovetailPart.TAIL,
-                    # tilt=20,
                     vertical_offset=-0.5,
                 ),
             )
@@ -238,7 +224,6 @@ class TestDovetail:
                     Point(5, 0),
                     taper_angle=0.5,
                     section=DovetailPart.TAIL,
-                    # tilt=20,
                     vertical_offset=0.5,
                 ),
             )

{b3dkit-0.1.0 → b3dkit-0.1.1}/tests/test_hexwall.py

@@ -11,7 +11,7 @@ from build123d import BuildPart, Box, Part, Sphere, Align, Mode, Location
 from b3dkit.hexwall import HexWall
 
 
-class TestClickfit:
+class TestHexWall:
     def test_hexwall(self):
         pattern = HexWall(10, 10, 1, 1, 0.2)
         assert pattern.is_valid