b3dkit 0.1.5__tar.gz → 0.3.2__tar.gz

b3dkit-0.3.2/.github/workflows/release.yml

@@ -0,0 +1,72 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install and test
+        run: |
+          python -m pip install --upgrade pip build
+          python -m pip install -e ".[dev]"
+          pytest -q
+
+      - name: Check the tag matches the packaged version
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          version=$(python -c "import re,pathlib;print(re.search(r'^version = \"([^\"]+)\"',pathlib.Path('pyproject.toml').read_text(),re.M).group(1))")
+          if [ "$tag" != "$version" ]; then
+            echo "::error::tag $GITHUB_REF_NAME does not match pyproject version $version"
+            exit 1
+          fi
+          echo "tag and version agree: $version"
+
+      - name: Build
+        run: python -m build
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write        # required for PyPI Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  smoke-test:
+    # Install the published artifact from PyPI and build something, mirroring the
+    # post-upload check the retired build.sh performed by hand.
+    needs: publish
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - name: Wait for PyPI to serve the new version
+        run: sleep 60
+      - name: Install from PyPI and build a part
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          python -m pip install --upgrade pip
+          python -m pip install "b3dkit==$version"
+          python -c "from b3dkit import Divot; assert Divot().is_valid; print('smoke test OK')"

b3dkit-0.3.2/.github/workflows/test.yml

@@ -0,0 +1,81 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: test-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+        build123d: [latest]
+        include:
+          # One job pinned at the declared dependency floor. b3dkit 0.1.5 shipped
+          # code that could not run against its own advertised minimum; this job
+          # is what stops that from happening again.
+          - python-version: "3.12"
+            build123d: floor
+
+    name: py${{ matrix.python-version }} / build123d ${{ matrix.build123d }}
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[dev]"
+
+      - name: Pin build123d to the declared floor
+        if: matrix.build123d == 'floor'
+        run: |
+          floor=$(python -c "import re,pathlib;print(re.search(r'build123d>=([0-9.]+)',pathlib.Path('pyproject.toml').read_text()).group(1))")
+          echo "Installing build123d==$floor"
+          python -m pip install "build123d==$floor"
+
+      - name: Show resolved versions
+        run: python -c "import sys,build123d;print(sys.version);print('build123d',build123d.__version__)"
+
+      - name: Run tests
+        run: pytest --cov=b3dkit --cov-report=term-missing --junitxml=junit.xml
+
+      - name: Fail if any test was skipped
+        # A green suite that silently skips is how the broken 0.10.0 floor reached
+        # PyPI: 27 tests were skipped and nothing complained.
+        if: always()
+        run: |
+          python - <<'PY'
+          import sys, xml.etree.ElementTree as ET
+          suite = ET.parse("junit.xml").getroot()
+          skipped = sum(int(s.get("skipped", 0)) for s in suite.iter("testsuite"))
+          if skipped:
+              print(f"::error::{skipped} test(s) skipped; the skip budget is zero")
+              sys.exit(1)
+          print("No skipped tests.")
+          PY
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: python -m pip install --upgrade pip ruff black
+      - run: ruff check .
+      - run: black --check .

b3dkit-0.3.2/.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.5
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+        stages: [manual]
+
+  - repo: https://github.com/psf/black
+    rev: 25.9.0
+    hooks:
+      - id: black
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: check-toml
+      - id: check-yaml
+      - id: check-merge-conflict

{b3dkit-0.1.5 → b3dkit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: b3dkit
-Version: 0.1.5
+Version: 0.3.2
 Summary: build123d libraries and utilities
 Project-URL: Homepage, https://github.com/x0pherl/b3dkit
 Project-URL: Issues, https://github.com/x0pherl/b3dkit/issues
@@ -10,8 +10,8 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Requires-Dist: build123d>=0.10.0
+Requires-Python: >=3.11
+Requires-Dist: build123d>=0.11.0
 Requires-Dist: ocp-vscode>=3.1.1
 Provides-Extra: dev
 Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'

{b3dkit-0.1.5 → b3dkit-0.3.2}/docs/basic_shapes.md

@@ -28,7 +28,7 @@ def apothem_to_radius(apothem: float, side_count: int = 6) -> float
 
 **Arguments**
 - `apothem` (float): The apothem of the polygon
-- `side_count` (float): The number of sides of the poygon.
+- `side_count` (int): The number of sides of the poygon.
 
 **Returns:**
 - `float`: The radius of the polygon
@@ -56,7 +56,7 @@ Finds the intersection point along one axis given a coordinate on the other axis
 ### distance_to_circle_edge
 
 ```python
-distance_to_circle_edge(radius: float, point: tuple, angle: float) -> float
+distance_to_circle_edge(radius: float, point: tuple[float, float], angle: float) -> float
 ```
 
 Calculates the distance from a given point to the edge of a circle in a specified direction.
@@ -87,15 +87,15 @@ Calculates the opposite side length of a right triangle given the angle and adja
 **Returns:**
 - `float`: The length of the opposite side
 
-### radius_to_appothem
+### radius_to_apothem
 
 ```python
-def radius_to_appothem(radius: float, side_count: int = 6) -> float
+def radius_to_apothem(radius: float, side_count: int = 6) -> float
 ```
 
 **Arguments:**
 - `radius` (float): the radius of the polygon
-- `side_count` (float): the number of sides of the polygon
+- `side_count` (int): the number of sides of the polygon
 
 **Returns:**
 - `float`: The apothem of the polygon
@@ -112,7 +112,7 @@ DiamondCylinder(
     radius: float,
     height: float,
     arc_size: float = 360,
-    stretch: tuple = (1, 1, 1),
+    stretch: tuple[float, float, float] = (1, 1, 1),
     rotation: RotationLike = (0, 0, 0),
     align: Align | tuple[Align, Align, Align] | None = None,
     mode: Mode = Mode.ADD,
@@ -123,7 +123,7 @@ DiamondCylinder(
 - `radius` (float): The radius of the circumscribed circle
 - `height` (float): The height of the extrusion
 - `arc_size` (float, default=360): Angular sweep in degrees for the circular clipping sector used to intersect the base profile
-- `stretch` (tuple, default=(1, 1, 1)): Scaling factors (X, Y, Z)
+- `stretch` (tuple[float, float, float], default=(1, 1, 1)): Scaling factors (X, Y, Z)
 - `rotation` (RotationLike, default=(0, 0, 0)): Rotation angles (X, Y, Z) in degrees
 - `align` (Align | tuple[Align, Align, Align] | None, default=None): Alignment along X, Y, Z axes
 - `mode` (Mode, default=Mode.ADD): Boolean combination mode
@@ -145,7 +145,7 @@ Creates a torus by sweeping a diamond (square rotated 45°) along a circular pat
 DiamondTorus(
     major_radius: float, 
     minor_radius: float, 
-    stretch: tuple = (1, 1)
+    stretch: tuple[float, float] = (1, 1)
 )
 ```
 
@@ -154,7 +154,7 @@ Creates a torus by sweeping a diamond (square rotated 45°) along a circular pat
 **Arguments:**
 - `major_radius` (float): The radius of the circular sweep path
 - `minor_radius` (float): The radius of the diamond cross-section
-- `stretch` (tuple, default=(1, 1)): Scaling factors for the diamond shape
+- `stretch` (tuple[float, float], default=(1, 1)): Scaling factors for the diamond shape
 - `rotation` (RotationLike, optional): angles to rotate about axes. Defaults to (0, 0, 0)
 - `align` (Align | tuple[Align, Align, Align] | None, optional): align MIN, CENTER,
         or MAX of object. Defaults to (Align.CENTER, Align.CENTER, Align.CENTER)
@@ -175,7 +175,7 @@ PolygonalCylinder(
     height: float,
     side_count: int = 6,
     arc_size: float = 360,
-    stretch: tuple = (1, 1, 1),
+    stretch: tuple[float, float, float] = (1, 1, 1),
     rotation: RotationLike = (0, 0, 0),
     align: Align | tuple[Align, Align, Align] | None = None,
     mode: Mode = Mode.ADD,
@@ -188,7 +188,7 @@ PolygonalCylinder(
 - `height` (float): The height of the extrusion
 - `side_count` (int, default=6): Number of sides of the polygon
 - `arc_size` (float, default=360): Angular sweep in degrees for the circular clipping sector used to intersect the base profile
-- `stretch` (tuple, default=(1, 1, 1)): Scaling factors (X, Y, Z)
+- `stretch` (tuple[float, float, float], default=(1, 1, 1)): Scaling factors (X, Y, Z)
 - `rotation` (RotationLike, default=(0, 0, 0)): Angles to rotate about axes
 - `align` (Align | tuple[Align, Align, Align] | None, default=None): Align MIN, CENTER, or MAX on each axis
 - `mode` (Mode, default=Mode.ADD): Boolean combination mode

b3dkit-0.3.2/docs/dovetail.md

@@ -0,0 +1,121 @@
+# Dovetail
+
+## Overview
+
+Dovetail is intended for breaking large parts into a dovetail and socketed part that can be easily fitted together with very tight and precise tolerances. This might be useful, for example, when designing parts that cannot fit onto common 3d-printer beds, and must be broken into multiple parts.
+
+![example of a part split into a dovetail and a socket](dovetail.png)
+
+The `dovetail_subpart` function takes a build123d part and the necessary parameters to break it into either the dovetail or the socket component of the split. Call it twice with the same arguments, changing only `subpart`, to produce a mating pair.
+
+All linear dimensions are in millimeters and all angles are in degrees.
+
+## Terminology
+
+- **subpart** — one of the two pieces produced by splitting a part. This is what `dovetail_subpart` returns, and the `subpart=` argument selects which one you get.
+- **tail** — the subpart carrying the protruding tongue (`DovetailSubpart.TAIL`).
+- **socket** — the subpart carrying the matching recess (`DovetailSubpart.SOCKET`).
+
+The two subparts are not equal halves: the tongue belongs to the tail, and for `SNUGTAIL` the joint wraps around three sides, so the socket is typically several times the volume of the tail.
+
+## Styles
+
+`style` selects the joint geometry, and **it determines which of the other arguments have any effect**:
+
+- `DovetailStyle.SNUGTAIL` *(default)* — an updated design for 3d printing that wraps around three sides of the object for a tighter fit and a large glue/friction surface.
+- `DovetailStyle.TRADITIONAL` — a traditional woodworking dovetail.
+- `DovetailStyle.T_SLOT` — a T-shaped tail, sized by slot count and depth rather than by tongue ratios.
+
+## Arguments
+
+### Always applicable
+
+- `part` (Part): The part to split into a dovetail or socket part. The part should be oriented along the XY plane.
+- `start` (Point): The start point along the XY Plane for the dovetail line.
+- `end` (Point): The end point along the XY Plane for the dovetail line.
+- `subpart` (DovetailSubpart, default=`DovetailSubpart.TAIL`): Which subpart to create — `DovetailSubpart.TAIL` or `DovetailSubpart.SOCKET`.
+- `style` (DovetailStyle, default=`DovetailStyle.SNUGTAIL`): The dovetail style. See [Styles](#styles).
+- `tolerance` (float, default=0.025): The clearance between tail and socket, in mm.
+- `vertical_tolerance` (float, default=0.2): Additional tolerance for vertical offset, given that in printing, supports or bridging introduce additional volume.
+- `scarf_angle` (float, default=0): Places the entire cut and dovetail at an angle along the Z-axis. Likely to improve stability in some parts.
+- `taper_angle` (float, default=0): Tapers the dovetail by the given angle. Even a small taper angle can allow for easier assembly.
+- `vertical_offset` (float, default=0): Offsets the dovetail along the Z axis, producing a straight cut on one side that acts as a hard stop when fitting. A positive value gives a straight cut on the bottom of the part, a negative value on the top.
+- `click_fit_radius` (float, default=0): The radius of the click-fit divots. `0` disables them.
+
+### Style-conditional
+
+The table below reflects what each parameter actually changes. Passing a parameter to a style that does not use it is currently accepted and silently ignored.
+
+| Argument | Default | TRADITIONAL | SNUGTAIL | T_SLOT |
+|---|---|---|---|---|
+| `length_ratio` | 1/3 | ✅ | ✅ | — |
+| `depth_ratio` | 1/6 | ✅ | — (see below) | — |
+| `tail_angle_offset` | 15 | ✅ | ✅ | — |
+| `linear_offset` | 0 | ✅ | — | — |
+| `slot_count` | 1 | — | — | ✅ |
+| `depth` | 2 | — | — | ✅ |
+
+- `length_ratio` (float, default=1/3): The ratio of the length of the tongue to the total length of the cut.
+- `depth_ratio` (float, default=1/6): The ratio of the depth of the tongue to the total length of the cut.
+- `tail_angle_offset` (float, default=15): The adjustment pitch of the angle of the dovetail. `0` results in a square dovetail.
+- `linear_offset` (float, default=0): Offsets the center of the tail or socket along the line by the amount specified. This slides the joint along the cut without changing its volume.
+- `slot_count` (int, default=1): The number of slots to be added.
+- `depth` (float, default=2): The depth of the T-slot into the socket.
+
+!!! note "`depth_ratio` and SNUGTAIL"
+
+    SNUGTAIL does not accept `depth_ratio` from `dovetail_subpart`; it uses its own
+    prototyped value of `0.15`. This is deliberate, not an oversight. The snugtail depth
+    model was rewritten after physical prototyping so that `depth_ratio` no longer means
+    what it means for TRADITIONAL, and forwarding the shared value would change the
+    geometry of every snugtail joint. `length_ratio` and `tail_angle_offset` *are*
+    honored for SNUGTAIL.
+
+## Returns
+
+- `Part`: The requested subpart — the tail or the socket, per `subpart`.
+
+## Example
+
+```python
+from build123d import Align, Box, BuildPart, Mode
+from b3dkit import Point, DovetailSubpart, DovetailStyle, dovetail_subpart
+
+with BuildPart(mode=Mode.PRIVATE) as longbox:
+    Box(50, 40, 50, align=(Align.CENTER, Align.CENTER, Align.MIN))
+
+start = Point(0, -20)
+end = Point(0, 20)
+
+# A mating pair with default parameters (SNUGTAIL).
+tail = dovetail_subpart(longbox.part, start, end, subpart=DovetailSubpart.TAIL)
+socket = dovetail_subpart(longbox.part, start, end, subpart=DovetailSubpart.SOCKET)
+```
+
+Both subparts of a joint must be built from the same arguments — only `subpart` may
+differ. Any other divergence produces two subparts that are individually valid and do
+not fit together.
+
+```python
+# A traditional dovetail with custom proportions.
+joint = dict(
+    style=DovetailStyle.TRADITIONAL,
+    tolerance=0.1,
+    scarf_angle=5,
+    taper_angle=2.0,
+    length_ratio=0.7,
+    depth_ratio=1 / 4,
+    click_fit_radius=0.2,
+)
+
+tail = dovetail_subpart(longbox.part, start, end, subpart=DovetailSubpart.TAIL, **joint)
+socket = dovetail_subpart(longbox.part, start, end, subpart=DovetailSubpart.SOCKET, **joint)
+```
+
+## Raises
+
+- `ValueError`: if `start` and `end` are the same point.
+- `ValueError`: if `abs(vertical_offset)` exceeds the part's height.
+- `ValueError`: if `vertical_offset` is negative and `taper_angle` is negative.
+- `ValueError`: if `vertical_offset` is positive and `taper_angle` is positive.
+- `ValueError`: for SNUGTAIL, if `length_ratio + depth_ratio` exceeds 1.

{b3dkit-0.1.5 → b3dkit-0.3.2}/docs/high_top_slide_box.md

@@ -84,6 +84,17 @@ Creates only the base component of the box. This includes the hollowed-out inter
 **Returns:**
 - `Part`: The base part with hollowed interior and rail channels
 
+## Dimension requirements
+
+All three functions validate their inputs and raise `ValueError` if the part cannot be
+built as a single solid:
+
+- `top_height`, `rail_height` and `wall_thickness` must all be greater than 0.
+- `wall_thickness * 2` must be less than the smaller of the part's width and depth.
+- At least `wall_thickness` of the part's height must remain below the rails, i.e.
+  `part_height - top_height - rail_height >= wall_thickness`. With less than that, the
+  divots have too little material to fuse into and break away as separate solids.
+
 ## Design Considerations
 
 ### Rail System

{b3dkit-0.1.5 → b3dkit-0.3.2}/docs/slide_box.md

@@ -64,34 +64,6 @@ Creates only the sliding lid component of the box. This is useful when you need
 **Returns:**
 - `Part`: The sliding lid part with taper and optional thumb grip
 
-### slider_template
-
-```python
-def slider_template(
-    sketch: Sketch,
-    wall_thickness: float = 2,
-    tolerance: float = 0.2,
-    top_offset: float = 0,
-    x_straighten_distance: float = 0,
-    divot_radius: float = 0,
-    cut_template: bool = True,
-) -> Part
-```
-
-Creates a slider template part based on a 2D sketch. This is an internal function used to generate the sliding mechanism geometry.
-
-**Arguments:**
-- `sketch` (Sketch): 2D sketch defining the slider cross-section
-- `wall_thickness` (float, default=2): Thickness of the walls
-- `tolerance` (float, default=0.2): Clearance for the sliding fit
-- `top_offset` (float, default=0): Vertical offset from the top
-- `x_straighten_distance` (float, default=0): Distance for straight sections at edges
-- `divot_radius` (float, default=0): Radius of divots
-- `cut_template` (bool, default=True): Whether this is for cutting (True) or building (False)
-
-**Returns:**
-- `Part`: The slider template part
-
 ## Design Principles
 
 ### Tapered Sliding Mechanism

{b3dkit-0.1.5 → b3dkit-0.3.2}/pyproject.toml

@@ -1,19 +1,19 @@
 [project]
 name = "b3dkit"
-version = "0.1.5"
+version = "0.3.2"
 authors = [
   { name="x0pherl"},
 ]
 description = "build123d libraries and utilities"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = [
-  "build123d>=0.10.0",
+  "build123d>=0.11.0",
   "ocp_vscode>=3.1.1",
 ]
 
@@ -48,6 +48,32 @@ build-backend = "hatchling.build"
 exclude = [".venv-1"]
 
 [tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "--strict-markers"
 markers = [
     "manual: marks tests that can only be executed manually",
-]
+]
+
+[tool.black]
+line-length = 88
+target-version = ["py311"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = [
+    "E501",  # line length is black's job
+    "B008",  # build123d builder-context idioms call in argument defaults
+    # build123d's builder pattern is `with BuildPart() as p:` where the binding
+    # is often unused -- the context manager does the work. 10 of the 12 F841
+    # hits in this package are that idiom, so the rule costs more than it earns.
+    "F841",
+]
+
+[tool.ruff.lint.per-file-ignores]
+# demo blocks under __main__ import the viewer after the module body starts
+"src/b3dkit/*.py" = ["E402"]

b3dkit-0.3.2/src/b3dkit/__init__.py

@@ -0,0 +1,92 @@
+"""build123d libraries and utilities.
+
+The names listed in ``__all__`` are b3dkit's public API; anything else is an
+implementation detail.
+"""
+
+from b3dkit.antichamfer import anti_chamfer
+from b3dkit.ball_socket import BallMount, BallSocket
+from b3dkit.basic_shapes import (
+    DiamondCylinder,
+    DiamondTorus,
+    PolygonalCylinder,
+    RoundedCylinder,
+    Teardrop,
+    TeardropCylinder,
+    adjacent_length,
+    apothem_to_radius,
+    circular_intersection,
+    distance_to_circle_edge,
+    opposite_length,
+    radius_to_apothem,
+)
+from b3dkit.bolt_fittings import (
+    BoltCutSinkhole,
+    HeatsinkCut,
+    NutCut,
+    ScrewCut,
+    SquareNutSinkhole,
+    TeardropBoltCutSinkhole,
+)
+from b3dkit.click_fit import Divot
+from b3dkit.dovetail import DovetailStyle, DovetailSubpart, dovetail_subpart
+from b3dkit.hexwall import HexCylindrical, HexWall
+from b3dkit.high_top_slide_box import (
+    high_top_slide_box,
+    high_top_slide_box_base,
+    high_top_slide_box_lid,
+)
+from b3dkit.point import Point, midpoint, shifted_midpoint
+from b3dkit.slide_box import slide_box, slide_lid
+from b3dkit.twist_snap import TwistSnapConnector, TwistSnapSocket
+
+__all__ = [
+    # antichamfer
+    "anti_chamfer",
+    # ball_socket
+    "BallMount",
+    "BallSocket",
+    # basic_shapes
+    "DiamondCylinder",
+    "DiamondTorus",
+    "PolygonalCylinder",
+    "RoundedCylinder",
+    "Teardrop",
+    "TeardropCylinder",
+    "adjacent_length",
+    "apothem_to_radius",
+    "circular_intersection",
+    "distance_to_circle_edge",
+    "opposite_length",
+    "radius_to_apothem",
+    # bolt_fittings
+    "BoltCutSinkhole",
+    "HeatsinkCut",
+    "NutCut",
+    "ScrewCut",
+    "SquareNutSinkhole",
+    "TeardropBoltCutSinkhole",
+    # click_fit
+    "Divot",
+    # dovetail
+    "DovetailSubpart",
+    "DovetailStyle",
+    "dovetail_subpart",
+    # hexwall
+    "HexCylindrical",
+    "HexWall",
+    # high_top_slide_box
+    "high_top_slide_box",
+    "high_top_slide_box_base",
+    "high_top_slide_box_lid",
+    # point
+    "Point",
+    "midpoint",
+    "shifted_midpoint",
+    # slide_box
+    "slide_box",
+    "slide_lid",
+    # twist_snap
+    "TwistSnapConnector",
+    "TwistSnapSocket",
+]

{b3dkit-0.1.5 → b3dkit-0.3.2}/src/b3dkit/antichamfer.py

@@ -1,10 +1,12 @@
+from math import atan, degrees
+
 from build123d import (
     Align,
     Axis,
     BasePartObject,
     Box,
-    BuildPart,
     Builder,
+    BuildPart,
     Compound,
     Face,
     Iterable,
@@ -17,8 +19,11 @@ from build123d import (
     flatten_sequence,
     validate_inputs,
 )
-from math import atan, degrees, tan, radians
-from ocp_vscode import show, Camera
+from ocp_vscode import Camera, show
+
+__all__ = [
+    "anti_chamfer",
+]
 
 
 def anti_chamfer(