b3dkit 0.5.0__tar.gz → 0.5.2__tar.gz

{b3dkit-0.5.0 → b3dkit-0.5.2}/CHANGELOG.md

@@ -7,6 +7,35 @@ ship in minor releases.
 
 ## [Unreleased]
 
+### Fixed
+
+- **build123d 0.12 and 0.13 support.** `TeardropBoltCutSinkhole`,
+  `BoltCutSinkhole`, `SquareNutSinkhole`, `TwistSnapSocket` and the
+  `high_top_slide_box` parts built the wrong geometry on build123d 0.12+, which
+  places geometry inside located builders differently. Every public object now
+  builds identically on 0.11, 0.12 and 0.13; 0.11 geometry is unchanged.
+- **`Teardrop`'s `rotation` is a float**, defaulting to `0`. The old `(0, 0)`
+  default raised `TypeError` on build123d 0.12+.
+
+## [0.5.2] - 2026-10-03
+
+### Changed
+
+- **`slide_box` sliding edges are filleted** by `wall_thickness * 0.025` on
+  both the slot and the lid.
+
+## [0.5.1] - 2026-10-01
+
+### Changed
+
+- **`slide_box` lids no longer intersect the box.** The lid was
+  `wall_thickness + tolerance` thick in a `wall_thickness` slot. `tolerance` is
+  now the total gap on every mating face, split evenly: the slot grows by half
+  and the lid shrinks by half, so the lid is `wall_thickness - tolerance / 2`
+  thick and its top stays flush. Box, lid and `slide_lid` geometry all change.
+- **`slide_box` divots now line up.** The box detents and lid bumps were placed
+  from different tolerances and sat up to `tolerance` apart.
+
 ## [0.5.0] - 2026-09-09
 
 ### Changed
@@ -146,7 +175,9 @@ the Python 3.11 floor.
 See the git history. b3dkit began as `fb-library`; the rename accompanied a
 rewrite that reworked names and usage to feel closer to native build123d.
 
-[Unreleased]: https://github.com/x0pherl/b3dkit/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/x0pherl/b3dkit/compare/v0.5.2...HEAD
+[0.5.2]: https://github.com/x0pherl/b3dkit/releases/tag/v0.5.2
+[0.5.1]: https://github.com/x0pherl/b3dkit/releases/tag/v0.5.1
 [0.5.0]: https://github.com/x0pherl/b3dkit/releases/tag/v0.5.0
 [0.4.0]: https://github.com/x0pherl/b3dkit/releases/tag/v0.4.0
 [0.3.2]: https://github.com/x0pherl/b3dkit/releases/tag/v0.3.2

{b3dkit-0.5.0 → b3dkit-0.5.2}/CONTRIBUTING.md

@@ -84,6 +84,11 @@ release, raise the floor in `pyproject.toml` in the same change. b3dkit 0.1.5
 shipped code that could not run against its own advertised minimum, which is
 what that CI job exists to prevent.
 
+Inside a `BuildPart` that has a location, do not open another builder or
+sketch, and give operations geometry from the builder (`builder.faces()`), not
+from `builder.part`. build123d 0.11 and 0.12+ place geometry differently in
+both cases.
+
 Do not add an upper bound. Caps propagate into every downstream resolution and
 convert a runtime failure into an install failure for everyone.
 

{b3dkit-0.5.0 → b3dkit-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: b3dkit
-Version: 0.5.0
+Version: 0.5.2
 Summary: build123d libraries and utilities
 Project-URL: Homepage, https://github.com/x0pherl/b3dkit
 Project-URL: Issues, https://github.com/x0pherl/b3dkit/issues

{b3dkit-0.5.0 → b3dkit-0.5.2}/docs/slide_box.md

@@ -45,7 +45,9 @@ The `x_straighten_distance` parameter controls how much of the sliding mechanism
 ## Design Considerations
 
 ### Tolerances
-The `tolerance` parameter controls the fit between the lid and base:
+The `tolerance` parameter is the total gap between the lid and base on every mating face, split evenly between the two: the slot grows by half of it and the lid shrinks by half of it. The lid is `wall_thickness - tolerance / 2` thick, with its top flush with the box.
+
+Typical values:
 - **0.1mm**: Very tight fit, may require force to operate
 - **0.15mm**: Standard fit (default) - smooth operation with minimal play
 - **0.2-0.25mm**: Loose fit for rough printing or materials that swell

{b3dkit-0.5.0 → b3dkit-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "b3dkit"
-version = "0.5.0"
+version = "0.5.2"
 authors = [
   { name="x0pherl"},
 ]
@@ -72,6 +72,8 @@ filterwarnings = [
     "ignore::DeprecationWarning:pyparsing.*",
     "default::DeprecationWarning:build123d.*",
     "default::PendingDeprecationWarning:build123d.*",
+    # build123d 0.13 renamed add() to insert(); 0.11 has no insert().
+    "ignore:add\\(\\) is deprecated:DeprecationWarning",
 ]
 
 [tool.black]

{b3dkit-0.5.0 → b3dkit-0.5.2}/src/b3dkit/antichamfer.py

@@ -11,7 +11,6 @@ from build123d import (
     Face,
     Iterable,
     Location,
-    Mode,
     Part,
     add,
     extrude,
@@ -78,18 +77,19 @@ def anti_chamfer(
     if length == 0 or length2 == 0:
         return target
 
+    taper = -degrees(atan(length2 / length))
+    if context is not None:
+        # extrude straight into the caller's builder: a builder opened here would
+        # nest inside it, and build123d 0.12 changed where nested builders place
+        # their geometry
+        for f in faces_list:
+            extrude(f.offset(-length), amount=length, taper=taper)
+        return Part(Compound([context.part]).wrapped)
+
     with BuildPart() as new_part:
         add(target)
         for f in faces_list:
-            extrude(
-                f.offset(-length),
-                amount=length,
-                taper=-degrees(atan(length2 / length)),
-            )
-    if context is not None:
-        context._add_to_context(
-            Part(Compound([new_part.part]).wrapped), mode=Mode.REPLACE
-        )
+            extrude(f.offset(-length), amount=length, taper=taper)
     return Part(Compound([new_part.part]).wrapped)
 
 

{b3dkit-0.5.0 → b3dkit-0.5.2}/src/b3dkit/basic_shapes.py

@@ -313,7 +313,7 @@ class Teardrop(BaseSketchObject):
         self,
         radius: float,
         peak_distance: float,
-        rotation: RotationLike = (0, 0),
+        rotation: float = 0,
         align: None | Align | tuple[Align, Align] = None,
         mode: Mode = Mode.ADD,
     ):

{b3dkit-0.5.0 → b3dkit-0.5.2}/src/b3dkit/bolt_fittings.py

@@ -92,7 +92,7 @@ class TeardropBoltCutSinkhole(BasePartObject):
                     amount=extension_distance,
                 )
             anti_chamfer(
-                sinkhole.part.faces().sort_by(Axis.Z)[-1],
+                sinkhole.faces().sort_by(Axis.Z)[-1],
                 chamfer_radius,
             )
         super().__init__(
@@ -205,7 +205,7 @@ class SquareNutSinkhole(BasePartObject):
                     nut_length,
                     align=(Align.CENTER, Align.MIN, Align.CENTER),
                 )
-                extrude(nut.part.faces().sort_by(Axis.Z)[-1], amount=nut_depth)
+                extrude(nut.faces().sort_by(Axis.Z)[-1], amount=nut_depth)
             if bolt_extension > 0:
                 with BuildPart(Location((0, bolt_depth + nut_height, 0))) as nut:
                     TeardropCylinder(

{b3dkit-0.5.0 → b3dkit-0.5.2}/src/b3dkit/high_top_slide_box.py

@@ -83,10 +83,11 @@ def _slide_top_rail_cut(
         -(part_depth - wall_thickness) / 2,
     )
 
-    with BuildPart(
-        Location((0, wall_thickness / 2, 0)),
-        mode=Mode.SUBTRACT,
-    ) as rail_cut:
+    # every child below is a nested builder or sketch, so this builder takes no
+    # location of its own: build123d 0.11 ignores a parent's location in nested
+    # builders and 0.12 composes it, so only an unlocated parent means the same
+    # thing to both
+    with BuildPart() as rail_cut:
         with BuildSketch(Location((0, wall_thickness / 2))):
             with BuildLine():
 
@@ -224,13 +225,15 @@ def _high_top_slide_box_top(
             )
         ):
             add(base_part)
-            with BuildPart(mode=Mode.INTERSECT):
-                Box(
-                    part_max_dimension,
-                    part_max_dimension,
-                    part_max_dimension,
-                    align=(Align.CENTER, Align.CENTER, Align.MIN),
-                )
+        # outside the located builder above, so it sits at z=0 on every
+        # build123d version
+        Box(
+            part_max_dimension,
+            part_max_dimension,
+            part_max_dimension,
+            align=(Align.CENTER, Align.CENTER, Align.MIN),
+            mode=Mode.INTERSECT,
+        )
         with BuildPart(
             Location((0, wall_thickness / 2, rail_height)),
             mode=Mode.SUBTRACT,
@@ -389,6 +392,19 @@ def high_top_slide_box_base(
     part_depth = base_part.bounding_box().size.Y
     part_height = base_part.bounding_box().size.Z
 
+    # built before any builder opens: inside one it would be a nested builder,
+    # and build123d 0.12 changed where nested builders place their geometry
+    top_cut = _high_top_slide_box_top(
+        base_part,
+        top_height,
+        rail_height,
+        wall_thickness,
+        rail_angle,
+        divot_radius,
+        tolerance,
+        cut_template=True,
+    )
+
     with BuildPart() as boxbottom:
         add(base_part)
         with BuildPart(
@@ -423,18 +439,7 @@ def high_top_slide_box_base(
             ),
             mode=Mode.SUBTRACT,
         ):
-            add(
-                _high_top_slide_box_top(
-                    base_part,
-                    top_height,
-                    rail_height,
-                    wall_thickness,
-                    rail_angle,
-                    divot_radius,
-                    tolerance,
-                    cut_template=True,
-                )
-            )
+            add(top_cut)
         with BuildPart(
             Location(
                 (

{b3dkit-0.5.0 → b3dkit-0.5.2}/src/b3dkit/slide_box.py

@@ -7,7 +7,7 @@ They are exempt from the compatibility promise in ``__all__`` until that is
 settled.
 """
 
-from math import radians, tan
+from math import cos, radians, tan
 
 from build123d import (
     Align,
@@ -43,6 +43,13 @@ __all__ = [
 ]
 
 
+def _tapered_inset(clearance: float) -> float:
+    """
+    The horizontal shift that moves a tapered face ``clearance`` along its normal.
+    """
+    return clearance / cos(radians(_SLIDER_TAPER_ANGLE))
+
+
 def _divot_spacing(
     sketch_width: float,
     wall_thickness: float,
@@ -59,14 +66,18 @@ def _divot_spacing(
     tapered face. A grazing intersection leaves needle-thin slivers behind the
     boolean, so pull the pair far enough inboard that a divot only ever meets the
     flat underside.
+
+    The spacing is measured against the lid's tapered face, the narrower of the
+    two, so the box and lid templates place their divots identically.
     """
     half_width = sketch_width / 2
+    lid_clearance = -abs(tolerance) / 2
     # depth below the top of the template at the widest point of the divot
-    widest_depth = max(wall_thickness - divot_radius, 0)
+    widest_depth = max(wall_thickness + lid_clearance - divot_radius, 0)
     tapered_face = (
         half_width
         - wall_thickness
-        - abs(tolerance)
+        + _tapered_inset(lid_clearance)
         + widest_depth * tan(radians(_SLIDER_TAPER_ANGLE))
     )
     return (
@@ -89,13 +100,21 @@ def _slider_template(
 ) -> Part:
     """
     Create a slider part based on a sketch.
+
+    ``tolerance`` is the total gap between lid and box; the cut template grows
+    by half of it and the lid template shrinks by half of it. The top of the
+    template stays at the top of the sketch either way.
     """
+    clearance = abs(tolerance) / 2 * (1 if cut_template else -1)
     with BuildPart() as slider_part:
         with BuildSketch() as top_sketch:
-            offset(sketch, amount=-abs(tolerance) - (abs(wall_thickness)))
+            offset(
+                sketch,
+                amount=-abs(wall_thickness) + _tapered_inset(clearance),
+            )
         extrude(
             top_sketch.sketch,
-            amount=-wall_thickness - abs(tolerance),
+            amount=-wall_thickness - clearance,
             taper=-_SLIDER_TAPER_ANGLE,
         )
         cross_section = section(
@@ -111,15 +130,20 @@ def _slider_template(
                 cross_section, amount=x_straighten_distance * 2 + wall_thickness * 2
             )
         )
+        fillet(
+            slider_part.edges() - slider_part.faces().filter_by(Plane.XY).edges(),
+            wall_thickness * 0.025,
+        )
+        fillet(slider_part.faces().sort_by(Axis.Z)[0].edges(), wall_thickness * 0.025)
+
         if divot_radius > 0:
             # a divot wider than half the wall would overhang the open front of
-            # the template; keep it far enough back to meet only the underside
-            divot_y = max(
-                sketch.bounding_box().min.Y + wall_thickness / 2,
-                slider_part.part.bounding_box().min.Y + divot_radius + divot_radius / 5,
+            # the part; keep it far enough back to meet only the underside
+            divot_y = sketch.bounding_box().min.Y + max(
+                wall_thickness / 2, divot_radius + divot_radius / 5
             )
             with BuildPart(
-                Location((0, divot_y, -wall_thickness), (180, 0, 0)),
+                Location((0, divot_y, -wall_thickness - clearance), (180, 0, 0)),
                 mode=Mode.ADD,
             ):
                 with GridLocations(
@@ -161,7 +185,7 @@ def slide_lid(
     args:
         - part: the part defining the box's outer dimensions
         - wall_thickness: the thickness of the box walls
-        - tolerance: the clearance between the lid and the base; 0.1 is a tight
+        - tolerance: the total gap between the lid and the base; 0.1 is a tight
             fit, 0.15 the default, 0.2 and above loose
         - top_offset: how far below the top of the part the sliding section sits,
             for parts with features at the top worth preserving
@@ -247,7 +271,8 @@ def slide_box(
         - thumb_radius: the radius of the thumb-grip cutout; 0 disables it
         - x_straighten_distance: how much of the slider stays straight at the
             edges, which stops wide lids binding at the corners
-        - tolerance: the clearance between the lid and the base
+        - tolerance: the total gap between the lid and the base, split evenly
+            between the slot and the lid
         - divot_radius: the radius of the click-fit positioning divots; 0
             disables them
 
@@ -260,7 +285,7 @@ def slide_box(
     lid_cut_template = _slider_template(
         cross_section,
         wall_thickness,
-        tolerance=0,
+        tolerance=tolerance,
         top_offset=top_offset,
         x_straighten_distance=x_straighten_distance,
         divot_radius=divot_radius,
@@ -303,11 +328,20 @@ def slide_box(
 
 
 if __name__ == "__main__":
-    from ocp_vscode import Camera, show
+    from ocp_vscode import show
 
     with BuildPart() as base_box:
         Box(20, 44, 14, align=(Align.CENTER, Align.CENTER, Align.MIN))
         fillet(base_box.part.edges().filter_by(Axis.Z), radius=1.5)
 
-    sb = slide_box(base_box.part, wall_thickness=2, thumb_radius=3.5, divot_radius=0.5)
-    show(sb, reset_camera=Camera.KEEP)
+    sb = slide_box(
+        base_box.part,
+        wall_thickness=2,
+        thumb_radius=3.5,
+        divot_radius=0.5,
+        tolerance=0.3,
+    )
+
+    show(
+        sb,
+    )

{b3dkit-0.5.0 → b3dkit-0.5.2}/src/b3dkit/twist_snap.py

@@ -204,8 +204,11 @@ class TwistSnapSocket(BasePartObject):
                     align=(Align.CENTER, Align.CENTER, Align.MIN),
                     mode=Mode.SUBTRACT,
                 )
+            # snap_socket.part, not snap_socket.edges(): build123d 0.12 reports a
+            # located builder's edges in its local frame, and this path is used
+            # outside it
             trace_path = (
-                snap_socket.edges()
+                snap_socket.part.edges()
                 .filter_by(GeomType.CIRCLE)
                 .sort_by(Axis.Z, reverse=True)
                 .sort_by(SortBy.RADIUS, reverse=True)[-1]

{b3dkit-0.5.0 → b3dkit-0.5.2}/tests/test_high_top_slide_box.py

@@ -90,6 +90,7 @@ class TestHighTopSlideBox:
         assert isinstance(lid, Part)
         assert_single_solid(lid, "lid")
         assert lid.label == "box top"
+        assert lid.volume == pytest.approx(1664.0654, rel=1e-4)
 
     def test_high_top_slide_box_lid_with_params(self, small_base_part):
         """Test high_top_slide_box_lid with various parameters."""

{b3dkit-0.5.0 → b3dkit-0.5.2}/tests/test_public_api.py

@@ -107,7 +107,7 @@ class TestPartObjectContract:
         against a shape it is given, so rotation and align cannot mean anything
         for it -- both were measurably inert when it still offered them.
         """
-        params = list(inspect.signature(getattr(b3dkit, name)).parameters)
+        params = list(inspect.signature(getattr(b3dkit, name).__init__).parameters)
         if name in POSITIONED_AGAINST_INPUT:
             assert params[-1] == "mode", f"{name} should still end with mode"
             assert (

b3dkit-0.5.2/tests/test_slide_box.py

@@ -0,0 +1,185 @@
+from math import cos, radians
+
+import pytest
+from build123d import (
+    Align,
+    Axis,
+    Box,
+    BuildPart,
+    Edge,
+    Location,
+    Plane,
+    fillet,
+    section,
+)
+
+from b3dkit.slide_box import _slider_template, slide_box
+
+
+class TestSlideBox:
+    def test_slide_box(self):
+        with BuildPart() as base_box:
+            Box(20, 44, 14, align=(Align.CENTER, Align.CENTER, Align.MIN))
+            fillet(base_box.part.edges().filter_by(Axis.Z), radius=1.5)
+
+        sb = slide_box(
+            base_box.part, wall_thickness=2, thumb_radius=3.5, divot_radius=0.5
+        )
+        box, lid = sb.children
+        assert (box.label, lid.label) == ("box", "lid")
+        assert len(box.solids()) == 1
+        assert len(lid.solids()) == 1
+        assert box.volume == pytest.approx(4604.7926, rel=1e-4)
+        assert lid.volume == pytest.approx(1344.8752, rel=1e-4)
+        # the lid slides inside the box, so it must be narrower
+        assert lid.bounding_box().size.X < box.bounding_box().size.X
+
+
+class TestSliderDivots:
+    """
+    The divots sit against the tapered sliding faces of the template. Placing one
+    so that it merely grazes a tapered face leaves needle-thin slivers behind the
+    boolean, which show up as a nick in the rail the lid slides through.
+
+    A pair of divots must therefore contribute exactly two solids, and each must
+    be a real divot rather than a sliver -- the two failure modes are a doubled
+    solid count and a solid orders of magnitude too small.
+    """
+
+    @pytest.fixture(scope="class")
+    @classmethod
+    def sketch(cls):
+        with BuildPart() as blank:
+            Box(60, 100, 20, align=(Align.CENTER, Align.CENTER, Align.MIN))
+            fillet(blank.part.edges().filter_by(Axis.Z), radius=1.5)
+        return section(obj=blank.part, section_by=Plane.XY.offset(20))
+
+    @staticmethod
+    def _divot_solids(sketch, wall, radius, tolerance, cut_template=True):
+        """the geometry the divots add to an otherwise identical template"""
+        with_divots = _slider_template(
+            sketch,
+            wall,
+            tolerance=tolerance,
+            divot_radius=radius,
+            cut_template=cut_template,
+        )
+        without_divots = _slider_template(
+            sketch, wall, tolerance=tolerance, divot_radius=0, cut_template=cut_template
+        )
+        return (with_divots - without_divots).solids()
+
+    @pytest.mark.parametrize("cut_template", [True, False])
+    @pytest.mark.parametrize("wall", [2.0, 3.0, 4.0])
+    @pytest.mark.parametrize("radius", [0.5, 0.75, 0.9, 1.0, 1.25])
+    def test_divots_contribute_exactly_two_solids(
+        self, sketch, wall, radius, cut_template
+    ):
+        # the sweep matters -- the tangency only bites on some wall/radius
+        # combinations, so any single pairing passes on its own
+        solids = self._divot_solids(
+            sketch, wall, radius, tolerance=0.2, cut_template=cut_template
+        )
+
+        assert len(solids) == 2
+        assert min(s.volume for s in solids) > radius**3 * 1e-2
+
+    def test_wide_divot_clears_the_open_front(self, sketch):
+        # a divot wider than half the wall used to overhang the front face of
+        # the template, slivering against it the same way the taper did
+        solids = self._divot_solids(sketch, wall=1.5, radius=1.25, tolerance=0.3)
+
+        assert len(solids) == 2
+        assert min(s.volume for s in solids) > 1.25**3 * 1e-2
+
+
+class TestSlideBoxFit:
+    """
+    The tolerance is the total gap between lid and box on every mating face:
+    the slot grows by half of it and the lid shrinks by half of it. The lid
+    top stays flush with the box top.
+    """
+
+    WALL = 2
+    TOP = 14
+
+    @pytest.fixture(scope="class")
+    @classmethod
+    def base(cls):
+        with BuildPart() as base_box:
+            Box(20, 44, cls.TOP, align=(Align.CENTER, Align.CENTER, Align.MIN))
+            fillet(base_box.part.edges().filter_by(Axis.Z), radius=1.5)
+        return base_box.part
+
+    def _fit(self, base, tolerance, divot_radius=0):
+        """the box and the lid flipped back into place on it"""
+        box, lid = slide_box(
+            base,
+            wall_thickness=self.WALL,
+            thumb_radius=0,
+            tolerance=tolerance,
+            divot_radius=divot_radius,
+        ).children
+        return box, lid.moved(Location((0, 0, 0), (0, 180, 0)))
+
+    @staticmethod
+    def _along_x(part, z):
+        """the edges where a line along +x at y=0 passes through the part"""
+        return (Edge.make_line((0, 0, z), (20, 0, z)) & part).edges()
+
+    @pytest.mark.parametrize("tolerance", [0.1, 0.15, 0.3])
+    def test_lid_thickness(self, base, tolerance):
+        _, lid = self._fit(base, tolerance)
+
+        assert lid.bounding_box().max.Z == pytest.approx(self.TOP, abs=1e-4)
+        assert lid.bounding_box().size.Z == pytest.approx(
+            self.WALL - tolerance / 2, abs=1e-4
+        )
+
+    @pytest.mark.parametrize("tolerance", [0.1, 0.15, 0.3])
+    def test_slot_depth(self, base, tolerance):
+        box, _ = self._fit(base, tolerance)
+        floor = self.TOP - self.WALL - tolerance / 2
+
+        def first_material(z):
+            return min(e.bounding_box().min.X for e in self._along_x(box, z))
+
+        # the slot floor is a ledge: just above it the opening reaches out to
+        # the rail, just below it only to the inner wall of the box
+        cavity_wall = 10 - self.WALL - tolerance
+        assert first_material(floor - 0.01) == pytest.approx(cavity_wall, abs=1e-4)
+        assert first_material(floor + 0.01) > cavity_wall + 0.5
+
+    @pytest.mark.parametrize("tolerance", [0.1, 0.15, 0.3])
+    def test_tapered_face_gap(self, base, tolerance):
+        box, lid = self._fit(base, tolerance)
+        z = self.TOP - 0.5
+
+        slot_face = min(e.bounding_box().min.X for e in self._along_x(box, z))
+        lid_face = max(e.bounding_box().max.X for e in self._along_x(lid, z))
+        # measured horizontally, a normal gap of `tolerance` on a face leaning
+        # 22.5 degrees
+        assert slot_face - lid_face == pytest.approx(
+            tolerance / cos(radians(22.5)), abs=1e-4
+        )
+
+    @pytest.mark.parametrize("divot_radius", [0, 0.5])
+    @pytest.mark.parametrize("tolerance", [0.1, 0.15, 0.3])
+    def test_no_interference(self, base, tolerance, divot_radius):
+        box, lid = self._fit(base, tolerance, divot_radius)
+
+        overlap = box & lid
+        assert sum(s.volume for s in overlap.solids()) == pytest.approx(0, abs=1e-6)
+
+    @pytest.mark.parametrize("tolerance", [0.1, 0.15, 0.3])
+    def test_divots_align(self, base, tolerance):
+        plain_box, plain_lid = self._fit(base, tolerance)
+        box, lid = self._fit(base, tolerance, divot_radius=0.5)
+
+        detents = sorted(
+            (s.center().X, s.center().Y) for s in (plain_box - box).solids()
+        )
+        bumps = sorted((s.center().X, s.center().Y) for s in (lid - plain_lid).solids())
+        assert len(detents) == len(bumps) == 2
+        for detent, bump in zip(detents, bumps, strict=True):
+            assert detent == pytest.approx(bump, abs=1e-4)

{b3dkit-0.5.0 → b3dkit-0.5.2}/tests/test_twist_snap.py

@@ -31,7 +31,7 @@ class TestTwistSnap:
         """
         import inspect
 
-        params = inspect.signature(TwistSnapConnector).parameters
+        params = inspect.signature(TwistSnapConnector.__init__).parameters
         assert "tolerance" not in params
         assert "wall_width" not in params
 

b3dkit-0.5.0/tests/test_slide_box.py

@@ -1,72 +0,0 @@
-import pytest
-from build123d import Align, Axis, Box, BuildPart, Plane, fillet, section
-
-from b3dkit.slide_box import _slider_template, slide_box
-
-
-class TestSlideBox:
-    def test_slide_box(self):
-        with BuildPart() as base_box:
-            Box(20, 44, 14, align=(Align.CENTER, Align.CENTER, Align.MIN))
-            fillet(base_box.part.edges().filter_by(Axis.Z), radius=1.5)
-
-        sb = slide_box(
-            base_box.part, wall_thickness=2, thumb_radius=3.5, divot_radius=0.5
-        )
-        box, lid = sb.children
-        assert (box.label, lid.label) == ("box", "lid")
-        assert len(box.solids()) == 1
-        assert len(lid.solids()) == 1
-        assert box.volume == pytest.approx(4632.0405, rel=1e-4)
-        assert lid.volume == pytest.approx(1498.3503, rel=1e-4)
-        # the lid slides inside the box, so it must be narrower
-        assert lid.bounding_box().size.X < box.bounding_box().size.X
-
-
-class TestSliderDivots:
-    """
-    The divots sit against the tapered sliding faces of the template. Placing one
-    so that it merely grazes a tapered face leaves needle-thin slivers behind the
-    boolean, which show up as a nick in the rail the lid slides through.
-
-    A pair of divots must therefore contribute exactly two solids, and each must
-    be a real divot rather than a sliver -- the two failure modes are a doubled
-    solid count and a solid orders of magnitude too small.
-    """
-
-    @pytest.fixture(scope="class")
-    @classmethod
-    def sketch(cls):
-        with BuildPart() as blank:
-            Box(60, 100, 20, align=(Align.CENTER, Align.CENTER, Align.MIN))
-            fillet(blank.part.edges().filter_by(Axis.Z), radius=1.5)
-        return section(obj=blank.part, section_by=Plane.XY.offset(20))
-
-    @staticmethod
-    def _divot_solids(sketch, wall, radius, tolerance):
-        """the geometry the divots add to an otherwise identical template"""
-        with_divots = _slider_template(
-            sketch, wall, tolerance=tolerance, divot_radius=radius, cut_template=True
-        )
-        without_divots = _slider_template(
-            sketch, wall, tolerance=tolerance, divot_radius=0, cut_template=True
-        )
-        return (with_divots - without_divots).solids()
-
-    @pytest.mark.parametrize("wall", [2.0, 3.0, 4.0])
-    @pytest.mark.parametrize("radius", [0.5, 0.75, 0.9, 1.0, 1.25])
-    def test_divots_contribute_exactly_two_solids(self, sketch, wall, radius):
-        # the sweep matters -- the tangency only bites on some wall/radius
-        # combinations, so any single pairing passes on its own
-        solids = self._divot_solids(sketch, wall, radius, tolerance=0.2)
-
-        assert len(solids) == 2
-        assert min(s.volume for s in solids) > radius**3 * 1e-2
-
-    def test_wide_divot_clears_the_open_front(self, sketch):
-        # a divot wider than half the wall used to overhang the front face of
-        # the template, slivering against it the same way the taper did
-        solids = self._divot_solids(sketch, wall=1.5, radius=1.25, tolerance=0.3)
-
-        assert len(solids) == 2
-        assert min(s.volume for s in solids) > 1.25**3 * 1e-2