diff --git a/.gitignore b/.gitignore index 062acb8b..74e1ac03 100644 --- a/.gitignore +++ b/.gitignore @@ -55,6 +55,7 @@ tools/research/out/ tools/research/histjson/out/ tools/research/whucad/out/ tools/research/cadqueryftc/out/ +tools/research/build123dftc/out/ .venv-cq/ # Source screen recordings stay local; compressed MP4/GIF derivatives are tracked diff --git a/docs/skill/references/docs/api/draft_rsolid.md b/docs/skill/references/docs/api/draft_rsolid.md new file mode 100644 index 00000000..3f08e272 --- /dev/null +++ b/docs/skill/references/docs/api/draft_rsolid.md @@ -0,0 +1,39 @@ +# draft_rsolid + +```python +def draft_rsolid( + solid: Solid, + faces_to_draft: Sequence[Face] | ShapeSelector, + angle: ScalarLike, + plane_origin: Sequence[float] = (0, 0, 0), + plane_normal: Sequence[float] = (0, 0, 1), +) -> Solid +``` + +*Source: operators/draft.py* + +Import with `from simplecadapi import draft_rsolid`. + +Apply a signed draft angle in degrees to selected planar, cylindrical, or +conical faces. The neutral plane retains its original section while the selected +faces lean toward or away from it. Its origin and normal use the current +coordinate system. The input solid is preserved, and the output must be one +valid solid. A zero angle records an unchanged result. + +```python +import simplecadapi as scad +from simplecadapi import ql + +body = scad.make_box_rsolid(10, 10, 10) +right = ql.faces().where(ql.prop("geom.normal.x", ">", 0.9)).exactly(1) +drafted = scad.draft_rsolid(body, right, angle=10) +``` + +Selections may be explicit faces from the body or a QL selector. Empty +selections, faces from another body, unsupported surface families, a zero plane +normal, and nonfinite parameters are rejected. The angle must be strictly +between -90 and 90 degrees. Kernel failures and invalid topology raise errors. + +The operation `make_draft_rsolid` records the body and selected faces as ordered +inputs. Parameters preserve the angle, neutral plane, and face selection nodes +for strict model JSON replay. diff --git a/docs/skill/references/docs/api/extrude_taper_rsolid.md b/docs/skill/references/docs/api/extrude_taper_rsolid.md new file mode 100644 index 00000000..c1422ecc --- /dev/null +++ b/docs/skill/references/docs/api/extrude_taper_rsolid.md @@ -0,0 +1,13 @@ +# extrude_taper_rsolid + +```python +def extrude_taper_rsolid(profile: Face, vector: Sequence[float], + taper: float, flip_inner: bool = True) -> Solid +``` + +Extrude a planar sketch face by a nonzero vector, in current coordinate-system +coordinates. The finite taper angle is in degrees and must lie strictly between +-90 and 90. Positive taper shrinks the outer section; inner loops taper in the +opposite direction when `flip_inner=True`. Uses an analytic draft prism where +applicable and exact offset sections with lofts otherwise. Raises on collapsed +loops or invalid topology. Records `make_extrude_taper_rsolid` for replay. diff --git a/docs/skill/references/docs/api/extrude_until_rsolid.md b/docs/skill/references/docs/api/extrude_until_rsolid.md new file mode 100644 index 00000000..dfa02468 --- /dev/null +++ b/docs/skill/references/docs/api/extrude_until_rsolid.md @@ -0,0 +1,53 @@ +# extrude_until_rsolid + +```python +def extrude_until_rsolid( + profile: Face, + target: Solid | Sequence[Solid], + direction: Sequence[float] = (0, 0, 1), + until: str = "NEXT", +) -> Solid +``` + +*Source: operators/limited_extrusion.py* + +Import with `from simplecadapi import extrude_until_rsolid`. + +Extrude a planar face until it reaches an actual boundary on one or more target +solids. Planar and curved termination surfaces are supported. The direction is +interpreted in the current coordinate system and normalized before construction. + +| Mode | Direction | Termination | +| --- | --- | --- | +| `NEXT` | Forward | Nearest intersecting target surface | +| `LAST` | Forward | Farthest intersecting target surface | +| `PREVIOUS` | Reverse | Nearest intersecting target surface | +| `FIRST` | Reverse | Farthest intersecting target surface | + +The implementation intersects a temporary prism with the target, obtains target +boundary faces from kernel history, sews the contact faces into surfaces, and +splits the prism on the selected surface. Bounding boxes only determine a +sufficient temporary prism length; they do not define the termination surface. +Side walls parallel to the direction do not join separate near and far limits. + +```python +import simplecadapi as scad + +profile = scad.make_rectangle_rface(2, 2) +ceiling = scad.make_box_rsolid(10, 10, 2, bottom_face_center=(0, 0, 5)) +near = scad.extrude_until_rsolid(profile, ceiling, until="NEXT") # Volume 20 +far = scad.extrude_until_rsolid(profile, ceiling, until="LAST") # Volume 28 + +sphere = scad.make_sphere_rsolid(5, center=(0, 0, 10)) +curved = scad.extrude_until_rsolid(profile, sphere) +``` + +Targets must cover the profile at the requested contact. Missing contact, +insufficient coverage, an invalid mode, a zero/nonfinite direction, and invalid +kernel output raise errors. An empty target sequence is rejected. A successful +result is one valid solid; inputs are preserved. + +The recorded operation is `make_extrude_until_rsolid`. Its ordered inputs are the +profile followed by every target solid. Parameters retain `direction`, `until`, +and `target_count`, so model JSON replay recomputes the boundary when a target +changes. No final BRep is embedded in the feature. diff --git a/docs/skill/references/docs/api/offset_rsolid.md b/docs/skill/references/docs/api/offset_rsolid.md new file mode 100644 index 00000000..7cb20429 --- /dev/null +++ b/docs/skill/references/docs/api/offset_rsolid.md @@ -0,0 +1,15 @@ +# offset_rsolid + +```python +def offset_rsolid(solid: Solid, amount: ScalarLike, + openings: Sequence[Face] | ShapeSelector = (), *, + tolerance: float = 1e-4, kind: str = "ARC") -> Solid +``` + +Positive `amount` offsets outward; negative offsets inward. The amount must +be finite and nonzero. QL-selected `openings` form an open shell. With no +openings, produce a closed offset solid. Join `kind` is `ARC` or +`INTERSECTION`. Invalid kernel results raise an error. Records a replayable +`make_offset_rsolid` node with explicit face selections; topology tag lineage +is conservatively partial. `shell_rsolid` retains its existing positive +inward wall-thickness contract. diff --git a/docs/skill/references/docs/api/scale_rsolid.md b/docs/skill/references/docs/api/scale_rsolid.md new file mode 100644 index 00000000..61c156bc --- /dev/null +++ b/docs/skill/references/docs/api/scale_rsolid.md @@ -0,0 +1,11 @@ +# scale_rsolid + +```python +def scale_rsolid(solid: Solid, factors: Sequence[float], center: Sequence[float] = (0, 0, 0)) -> Solid +``` + +Scale a solid along the current coordinate system's axes about `center`. +The three factors must be finite and nonzero. Uniform scaling preserves +analytic curves and surfaces; nonuniform scaling uses the CAD kernel's +general affine transform. The source stays unchanged. Records a replayable +`make_scale_rsolid` operation. Topology tag lineage is conservatively partial. diff --git a/docs/skill/references/docs/api/sweep_multisection_rsolid.md b/docs/skill/references/docs/api/sweep_multisection_rsolid.md new file mode 100644 index 00000000..4fc25630 --- /dev/null +++ b/docs/skill/references/docs/api/sweep_multisection_rsolid.md @@ -0,0 +1,12 @@ +# sweep_multisection_rsolid + +```python +def sweep_multisection_rsolid(profiles: Sequence[Face | Wire], path: Wire, + is_frenet: bool = False, binormal: Sequence[float] | Wire | None = None) -> Solid +``` + +Sweep through at least two ordered sections along a continuous path. Face +sections supply their outer wire, matching build123d's multi-section sweep +contract. Binormal is an optional direction or auxiliary spine. The kernel +must produce one valid solid. Every section and path is recorded as an input +of `make_sweep_multisection_rsolid`, so model JSON preserves the construction. diff --git a/docs/skill/references/docs/api/transform_rsolid.md b/docs/skill/references/docs/api/transform_rsolid.md new file mode 100644 index 00000000..fba928a7 --- /dev/null +++ b/docs/skill/references/docs/api/transform_rsolid.md @@ -0,0 +1,10 @@ +# transform_rsolid + +```python +def transform_rsolid(solid: Solid, matrix: Sequence[Sequence[float]]) -> Solid +``` + +Apply a finite nonsingular 4x4 affine matrix in the current coordinate system, +including shear, reflection and nonuniform scale. Reject perspective and +singular matrices. Input geometry stays unchanged. Records a replayable +`make_transform_rsolid` operation; topology tag lineage is partial. diff --git a/src/simplecadapi/__init__.py b/src/simplecadapi/__init__.py index 839f9a33..16769cd4 100644 --- a/src/simplecadapi/__init__.py +++ b/src/simplecadapi/__init__.py @@ -69,6 +69,10 @@ get_current_cs, ) from .errors import SimpleCADError +from .operators.deformation import scale_rsolid, offset_rsolid, transform_rsolid, boolean_rsolidlist +from .operators.section_features import extrude_taper_rsolid, sweep_multisection_rsolid +from .operators.limited_extrusion import extrude_until_rsolid +from .operators.draft import draft_rsolid from .params.expr import ( Const, DimensionTolerance, @@ -433,6 +437,14 @@ def notebook_id() -> str: __all__ = [ + "scale_rsolid", + "boolean_rsolidlist", + "transform_rsolid", + "offset_rsolid", + "extrude_taper_rsolid", + "sweep_multisection_rsolid", + "extrude_until_rsolid", + "draft_rsolid", "exporter", # 核心类 "CoordinateSystem", diff --git a/src/simplecadapi/kernel/ocp_properties.py b/src/simplecadapi/kernel/ocp_properties.py index 941c6eba..1e14f543 100644 --- a/src/simplecadapi/kernel/ocp_properties.py +++ b/src/simplecadapi/kernel/ocp_properties.py @@ -107,7 +107,9 @@ def surface_area(face: TopoDS_Face) -> float: def volume(solid: TopoDS_Solid) -> float: props = GProp_GProps() - BRepGProp.VolumeProperties_s(solid, props) + # Integrate NURBS by knot spans. The fixed-order routine both loses + # precision on rational curves and can crash on affine transformed trims. + BRepGProp.VolumePropertiesGK_s(solid, props, 1e-9, True, True) return float(props.Mass()) @@ -146,7 +148,7 @@ def center_of_mass(shape: TopoDS_Shape) -> Vec3: if kind in (TopAbs_SOLID, TopAbs_COMPSOLID, TopAbs_COMPOUND): props = GProp_GProps() try: - BRepGProp.VolumeProperties_s(shape, props) + BRepGProp.VolumePropertiesGK_s(shape, props, 1e-9, True, True) point = _props_mass_point(props) if point is not None: return point diff --git a/src/simplecadapi/operators/__init__.py b/src/simplecadapi/operators/__init__.py index 9942bbba..4f3299d8 100644 --- a/src/simplecadapi/operators/__init__.py +++ b/src/simplecadapi/operators/__init__.py @@ -16,7 +16,7 @@ import sys as _sys from types import ModuleType as _ModuleType -from . import _support, geometry, transform, boolean, product, sketch, selection, features +from . import _support, geometry, transform, boolean, product, sketch, selection, features, deformation, section_features, limited_extrusion, draft from ._support import * from .geometry import * from .transform import * @@ -25,6 +25,10 @@ from .sketch import * from .selection import * from .features import * +from .deformation import * +from .section_features import * +from .limited_extrusion import * +from .draft import * _IMPLEMENTATION_MODULES = ( _support, @@ -35,6 +39,10 @@ sketch, selection, features, + deformation, + section_features, + limited_extrusion, + draft, ) __all__ = tuple( diff --git a/src/simplecadapi/operators/_support.py b/src/simplecadapi/operators/_support.py index 57f7a77a..c5c1576e 100644 --- a/src/simplecadapi/operators/_support.py +++ b/src/simplecadapi/operators/_support.py @@ -1245,6 +1245,7 @@ def _record_geo_selection_nodes( op=op, params={ "target_kind": kind, + "source_output_slot": int(source_shape._get_runtime("graph.output_slot", 0)), "geo_selector": _make_geo_selector( selected, source_shape=source_shape, diff --git a/src/simplecadapi/operators/deformation.py b/src/simplecadapi/operators/deformation.py new file mode 100644 index 00000000..1121be9f --- /dev/null +++ b/src/simplecadapi/operators/deformation.py @@ -0,0 +1,217 @@ +"""Recorded scaling and signed offsets for CAD source translation.""" +from __future__ import annotations + +import math +from typing import Sequence + +import numpy as np +from OCP.BRepBuilderAPI import BRepBuilderAPI_Copy, BRepBuilderAPI_GTransform, BRepBuilderAPI_Transform +from OCP.BRepCheck import BRepCheck_Analyzer +from OCP.BRepGProp import BRepGProp +from OCP.BRepOffsetAPI import BRepOffsetAPI_MakeThickSolid +from OCP.GeomAbs import GeomAbs_Arc, GeomAbs_Intersection +from OCP.GProp import GProp_GProps +from OCP.TopTools import TopTools_ListOfShape +from OCP.gp import gp_GTrsf, gp_Pnt, gp_Trsf + +from ._support import ( + Solid, Face, ShapeSelector, ScalarLike, evaluate_scalar, evaluate_value, + get_current_cs, solids_of, record_operation_if_active, + _attach_lineage_from_source, _current_context_metadata, + _ensure_geo_selection_node_ids, _resolve_selector_or_shapes, + _serialize_shape_refs, + _ensure_geo_selection_input_nodes, +) + + +def _finite_vector(value: Sequence[float], name: str) -> tuple[float, float, float]: + values = tuple(float(v) for v in evaluate_value(value)) + if len(values) != 3 or not all(math.isfinite(v) for v in values): + raise ValueError(f"{name} must contain three finite numbers") + return values + + +def _finish(source: Solid, wrapped, op: str, params: dict, inputs: list) -> Solid: + solids = solids_of(wrapped) + if len(solids) != 1: + raise ValueError(f"{op} must produce exactly one solid, got {len(solids)}") + result = Solid(solids[0]) + props = GProp_GProps() + BRepGProp.VolumePropertiesGK_s(result.wrapped, props, 1e-9, True, True) + if props.Mass() < 0: + result.wrapped.Reverse() + if not BRepCheck_Analyzer(result.wrapped).IsValid(): + raise ValueError(f"{op} produced invalid geometry") + result._metadata = source._metadata.copy() + # These builders do not yet provide a complete face-history channel. + _attach_lineage_from_source(source, result, derivation="continuation", op=op, coverage="partial") + _ensure_geo_selection_input_nodes(inputs) + params = {**params, "input_refs": _serialize_shape_refs(inputs)} + record_operation_if_active(op=op, params=params, outputs=result, + input_shapes=inputs, context=_current_context_metadata()) + return result + + +def scale_rsolid( + solid: Solid, + factors: Sequence[float], + center: Sequence[float] = (0, 0, 0), +) -> Solid: + """Scale along current coordinate-system axes about an explicit center. + + Every factor must be finite and nonzero. A uniform scale preserves analytic + geometry; a nonuniform scale converts curves/surfaces where the kernel needs + it. The input is unchanged and this operation is recorded for graph replay. + """ + values = _finite_vector(factors, "factors") + center_value = _finite_vector(center, "center") + if any(v == 0 for v in values): + raise ValueError("scale factors must be nonzero") + cs = get_current_cs() + global_center = cs.transform_point(np.array(center_value)) + if values[0] == values[1] == values[2]: + transform = gp_Trsf() + transform.SetScale(gp_Pnt(*global_center), values[0]) + builder = BRepBuilderAPI_Transform(solid.wrapped, transform, True) + else: + basis = np.column_stack([cs.transform_vector(np.eye(3)[i]) for i in range(3)]) + matrix = basis @ np.diag(values) @ basis.T + translation = global_center - matrix @ global_center + transform = gp_GTrsf() + for row in range(3): + for col in range(3): + transform.SetValue(row + 1, col + 1, float(matrix[row, col])) + transform.SetValue(row + 1, 4, float(translation[row])) + # GTransform's copy flag copies topology, but can retain shared curve + # geometry from boolean/fillet history. Isolate that geometry first: + # otherwise OCCT 7.9 can produce invalid p-curves and crash its checker. + copied = BRepBuilderAPI_Copy(solid.wrapped, True, False).Shape() + builder = BRepBuilderAPI_GTransform(copied, transform, True) + builder.Build() + if not builder.IsDone(): + raise ValueError("kernel could not scale the solid") + return _finish(solid, builder.Shape(), "make_scale_rsolid", + {"factors": factors, "center": center}, [solid]) + + +def transform_rsolid(solid: Solid, matrix: Sequence[Sequence[float]]) -> Solid: + """Apply a finite nonsingular 4x4 affine matrix in the current frame. + + General affine transformations include shear and reflection. Perspective + matrices and singular maps cannot define a solid and are rejected. + """ + values = np.asarray(evaluate_value(matrix), dtype=float) + if values.shape != (4, 4) or not np.isfinite(values).all(): + raise ValueError("matrix must be a finite 4x4 affine matrix") + if not np.allclose(values[3], (0, 0, 0, 1), rtol=0, atol=1e-12): + raise ValueError("perspective transforms cannot define an affine solid") + if abs(float(np.linalg.det(values[:3, :3]))) < 1e-14: + raise ValueError("matrix must be nonsingular") + cs = get_current_cs() + basis = np.column_stack([cs.transform_vector(np.eye(3)[i]) for i in range(3)]) + origin = cs.transform_point(np.zeros(3)) + linear = basis @ values[:3, :3] @ basis.T + translation = origin + basis @ values[:3, 3] - linear @ origin + transform = gp_GTrsf() + for row in range(3): + for col in range(3): + transform.SetValue(row + 1, col + 1, float(linear[row, col])) + transform.SetValue(row + 1, 4, float(translation[row])) + copied = BRepBuilderAPI_Copy(solid.wrapped, True, False).Shape() + builder = BRepBuilderAPI_GTransform(copied, transform, True) + builder.Build() + if not builder.IsDone(): + raise ValueError("kernel could not transform the solid") + return _finish(solid, builder.Shape(), "make_transform_rsolid", {"matrix": matrix}, [solid]) + + +def offset_rsolid( + solid: Solid, + amount: ScalarLike, + openings: Sequence[Face] | ShapeSelector = (), + *, + tolerance: float = 1e-4, + kind: str = "ARC", +) -> Solid: + """Offset a solid outward (positive) or inward (negative). + + Selected openings form an open shell. Empty openings produce the closed + offset solid. This is distinct from shell_rsolid's positive inward wall + thickness, and supports both signs and ARC/INTERSECTION joins explicitly. + """ + distance = evaluate_scalar(amount) + if not math.isfinite(distance) or distance == 0: + raise ValueError("amount must be finite and nonzero") + if not math.isfinite(tolerance) or tolerance <= 0: + raise ValueError("tolerance must be finite and positive") + joins = {"ARC": GeomAbs_Arc, "INTERSECTION": GeomAbs_Intersection} + if kind not in joins: + raise ValueError("kind must be ARC or INTERSECTION") + faces = list(_resolve_selector_or_shapes(solid, openings)) + if any(not isinstance(face, Face) for face in faces): + raise ValueError("openings must select faces") + selected_ids = _ensure_geo_selection_node_ids(solid, faces) + face_list = TopTools_ListOfShape() + for face in faces: + face_list.Append(face.wrapped) + builder = BRepOffsetAPI_MakeThickSolid() + builder.MakeThickSolidByJoin(solid.wrapped, face_list, distance, tolerance, + Intersection=True, RemoveIntEdges=True, Join=joins[kind]) + builder.Build() + if not builder.IsDone(): + raise ValueError("kernel could not offset the solid") + params = {"amount": amount, "tolerance": tolerance, "kind": kind, + "removed_face_count": len(faces), "selected_faces": _serialize_shape_refs(faces)} + if selected_ids: + params["selected_face_node_ids"] = selected_ids + return _finish(solid, builder.Shape(), "make_offset_rsolid", params, [solid, *faces]) + + +def boolean_rsolidlist( + left: Sequence[Solid], + right: Sequence[Solid], + operation: str, +) -> list[Solid]: + """Apply a set boolean to two body groups, retaining every result solid. + + Members of each group are a geometric set. Unlike single-solid booleans, + a cut or intersection may return several solids or an empty list. + Topology lineage is partial; the ordered inputs and all output slots are + recorded so downstream features can replay the same geometry. + """ + from ..kernel.ocp_booleans import cut_shapes, common_shapes, fuse_shapes + from ..kernel.ocp_export import make_compound_always + lhs, rhs = list(left), list(right) + if operation not in {"cut", "intersect", "union"}: + raise ValueError("operation must be cut, intersect or union") + inputs = [*lhs, *rhs] + if any(not isinstance(body, Solid) for body in inputs): + raise TypeError("boolean groups must contain Solid values") + if any(body.wrapped.IsNull() or not BRepCheck_Analyzer(body.wrapped).IsValid() for body in inputs): + raise ValueError("boolean groups must contain valid nonempty topology") + if operation == "union": + shape = fuse_shapes([body.wrapped for body in inputs]) if inputs else None + elif not lhs or (operation == "intersect" and not rhs): + shape = None + elif operation == "cut": + shape = cut_shapes(make_compound_always([body.wrapped for body in lhs]), + [body.wrapped for body in rhs]) + else: + shape = common_shapes([make_compound_always([body.wrapped for body in group]) + for group in (lhs, rhs)]) + if shape is not None and not BRepCheck_Analyzer(shape).IsValid(): + raise ValueError("set boolean produced invalid topology") + result = [Solid(solid) for solid in solids_of(shape)] if shape is not None else [] + for body in result: + for source in inputs: + _attach_lineage_from_source(source, body, derivation="continuation", + op="make_boolean_rsolidlist", coverage="partial") + _ensure_geo_selection_input_nodes(inputs) + record_operation_if_active(op="make_boolean_rsolidlist", + params={"operation": operation, "left_count": len(lhs), "right_count": len(rhs), + "input_refs": _serialize_shape_refs(inputs)}, outputs=result, + input_shapes=inputs, context=_current_context_metadata()) + return result + + +__all__ = ("scale_rsolid", "offset_rsolid", "transform_rsolid", "boolean_rsolidlist") diff --git a/src/simplecadapi/operators/draft.py b/src/simplecadapi/operators/draft.py new file mode 100644 index 00000000..1b427779 --- /dev/null +++ b/src/simplecadapi/operators/draft.py @@ -0,0 +1,83 @@ +"""Draft selected analytic solid faces around a recorded neutral plane.""" +from __future__ import annotations + +import math +from typing import Sequence + +import numpy as np +from OCP.BRepAdaptor import BRepAdaptor_Surface +from OCP.BRepOffsetAPI import BRepOffsetAPI_DraftAngle +from OCP.GeomAbs import GeomAbs_Plane, GeomAbs_Cylinder, GeomAbs_Cone +from OCP.gp import gp_Dir, gp_Pln, gp_Pnt + +from ._support import ( + Face, Solid, ShapeSelector, ScalarLike, evaluate_scalar, get_current_cs, + _resolve_selector_or_shapes, _ensure_geo_selection_node_ids, _serialize_shape_refs, +) +from .deformation import _finish, _finite_vector + + +def draft_rsolid( + solid: Solid, + faces_to_draft: Sequence[Face] | ShapeSelector, + angle: ScalarLike, + plane_origin: Sequence[float] = (0, 0, 0), + plane_normal: Sequence[float] = (0, 0, 1), +) -> Solid: + """Draft planar, cylindrical or conical faces by a signed angle in degrees. + + The neutral plane fixes the unchanged section. Its origin and normal are in + current coordinate-system coordinates. Face selection is checked against + the input body and retained as graph inputs for strict replay. The original + solid is preserved. Other surface families are explicitly rejected. + """ + if not isinstance(solid, Solid): + raise TypeError("solid must be a Solid") + degrees = float(evaluate_scalar(angle)) + if not math.isfinite(degrees) or abs(degrees) >= 90: + raise ValueError("angle must be finite and strictly between -90 and 90 degrees") + origin = _finite_vector(plane_origin, "plane_origin") + normal = _finite_vector(plane_normal, "plane_normal") + cs = get_current_cs() + global_origin = cs.transform_point(np.asarray(origin)) + global_normal = cs.transform_vector(np.asarray(normal)) + magnitude = float(np.linalg.norm(global_normal)) + if magnitude <= 1e-14: + raise ValueError("plane_normal must be nonzero") + global_normal = global_normal / magnitude + selected = list(_resolve_selector_or_shapes(solid, faces_to_draft)) + if not selected: + raise ValueError("draft requires at least one selected face") + original_faces = solid._iter_faces() + for face in selected: + if not isinstance(face, Face): + raise ValueError("faces_to_draft must select only Face objects") + if not any(face.wrapped.IsSame(other.wrapped) for other in original_faces): + raise ValueError("selected draft faces must belong to the input solid") + if BRepAdaptor_Surface(face.wrapped).GetType() not in {GeomAbs_Plane, GeomAbs_Cylinder, GeomAbs_Cone}: + raise ValueError("draft supports only planar, cylindrical, and conical faces") + # Remove repeated references without changing the ordered face selection. + selected = list({face.topo_id: face for face in selected}.values()) + selected_ids = _ensure_geo_selection_node_ids(solid, selected) + if degrees == 0: + shape = solid.wrapped + else: + direction = gp_Dir(*global_normal) + plane = gp_Pln(gp_Pnt(*global_origin), direction) + builder = BRepOffsetAPI_DraftAngle(solid.wrapped) + for face in selected: + builder.Add(face.wrapped, direction, math.radians(degrees), plane, True) + if not builder.AddDone(): + raise ValueError("kernel could not add the requested draft angle to a selected face") + builder.Build() + if not builder.IsDone(): + raise ValueError("kernel could not build the drafted solid") + shape = builder.Shape() + params = {"angle": angle, "plane_origin": plane_origin, "plane_normal": plane_normal, + "selected_face_count": len(selected), "selected_faces": _serialize_shape_refs(selected)} + if selected_ids: + params["selected_face_node_ids"] = selected_ids + return _finish(solid, shape, "make_draft_rsolid", params, [solid, *selected]) + + +__all__ = ("draft_rsolid",) diff --git a/src/simplecadapi/operators/limited_extrusion.py b/src/simplecadapi/operators/limited_extrusion.py new file mode 100644 index 00000000..b6de8f27 --- /dev/null +++ b/src/simplecadapi/operators/limited_extrusion.py @@ -0,0 +1,180 @@ +"""Recorded extrusion terminated by a real target face or curved shell. + +The construction follows the surface-history approach used by build123d: +intersect a long prism, sew the affected target faces, order contact surfaces, +and split by the selected surface. Bounding boxes only bound the temporary +prism; they never define the termination surface. +""" +from __future__ import annotations + +import math +from typing import Sequence + +import numpy as np +from OCP.BRepAlgoAPI import BRepAlgoAPI_Common, BRepAlgoAPI_Splitter +from OCP.BRepBuilderAPI import BRepBuilderAPI_Sewing +from OCP.BRepCheck import BRepCheck_Analyzer +from OCP.BRepGProp import BRepGProp, BRepGProp_Face +from OCP.BRepPrimAPI import BRepPrimAPI_MakeHalfSpace, BRepPrimAPI_MakePrism +from OCP.BRepTools import BRepTools +from OCP.GProp import GProp_GProps +from OCP.TopAbs import TopAbs_COMPOUND, TopAbs_FACE, TopAbs_SHELL +from OCP.TopoDS import TopoDS, TopoDS_Iterator +from OCP.TopTools import TopTools_ListOfShape +from OCP.gp import gp_Pnt, gp_Vec + +from ..kernel.ocp_booleans import solids_of +from ..kernel.ocp_export import make_compound_always +from ..kernel.ocp_properties import bounding_box, center_of_mass, distance, volume +from ..kernel.ocp_topology import faces_of +from ._support import Face, Solid, evaluate_value, get_current_cs +from .deformation import _finish, _finite_vector + + +def _top_level(shape): + if shape.ShapeType() != TopAbs_COMPOUND: + return [shape] + output = [] + iterator = TopoDS_Iterator(shape) + while iterator.More(): + output.extend(_top_level(iterator.Value())) + iterator.Next() + return output + + +def _crosses_direction(face, axis): + """Ignore side walls tangent to the extrusion, including coincident walls.""" + u0, u1, v0, v1 = BRepTools.UVBounds_s(face) + properties = BRepGProp_Face(face) + for u in (.25, .5, .75): + for v in (.25, .5, .75): + point, normal = gp_Pnt(), gp_Vec() + properties.Normal(u0 + u * (u1-u0), v0 + v * (v1-v0), point, normal) + length = normal.Magnitude() + if length > 1e-14 and abs(normal.X()*axis[0] + normal.Y()*axis[1] + normal.Z()*axis[2]) / length > 1e-8: + return True + return False + + +def _contact_surfaces(target, prism, axis): + common = BRepAlgoAPI_Common(target, prism) + common.Build() + if not common.IsDone() or not faces_of(common.Shape()): + raise ValueError("No intersection: extrusion does not contact target") + history = common.History() + modified = [] + intersection_faces = faces_of(common.Shape()) + for face in faces_of(target): + affected = list(history.Modified(face)) + if affected: + modified.extend(TopoDS.Face_s(item) for item in affected if item.ShapeType() == TopAbs_FACE) + elif not history.IsRemoved(face) and any(item.IsSame(face) for item in intersection_faces): + # A whole target may lie inside the temporary prism, in which case + # unchanged boundary faces are still genuine contact surfaces. + modified.append(face) + if not modified: + raise ValueError("No target boundary surfaces found in extrusion intersection") + sewing = BRepBuilderAPI_Sewing(1e-6) + for face in modified: + if _crosses_direction(face, axis): + sewing.Add(face) + sewing.Perform() + surfaces = _top_level(sewing.SewedShape()) + if not surfaces or any(part.ShapeType() not in {TopAbs_FACE, TopAbs_SHELL} for part in surfaces): + raise ValueError("Kernel could not sew target contact surfaces") + return surfaces + + +def _split_on_surface(prism, surface, keep_top): + arguments, tools = TopTools_ListOfShape(), TopTools_ListOfShape() + arguments.Append(prism) + tools.Append(surface) + splitter = BRepAlgoAPI_Splitter() + splitter.SetArguments(arguments) + splitter.SetTools(tools) + splitter.Build() + if not splitter.IsDone(): + raise ValueError("Kernel could not split extrusion on target surface") + reference_face = TopoDS.Face_s(surface) if surface.ShapeType() == TopAbs_FACE else faces_of(surface)[0] + u0, u1, v0, v1 = BRepTools.UVBounds_s(reference_face) + point, normal = gp_Pnt(), gp_Vec() + BRepGProp_Face(reference_face).Normal((u0+u1)/2, (v0+v1)/2, point, normal) + if normal.Magnitude() <= 1e-14: + raise ValueError("Undefined normal on termination surface") + normal.Normalize() + reference = point.Translated(normal) + if surface.ShapeType() == TopAbs_FACE: + halfspace = BRepPrimAPI_MakeHalfSpace(TopoDS.Face_s(surface), reference).Solid() + else: + halfspace = BRepPrimAPI_MakeHalfSpace(TopoDS.Shell_s(surface), reference).Solid() + candidates = [] + for part in solids_of(splitter.Shape()): + common = BRepAlgoAPI_Common(part, halfspace) + common.Build() + if not common.IsDone(): + raise ValueError("Kernel could not classify the termination side") + properties = GProp_GProps() + BRepGProp.LinearProperties_s(common.Shape(), properties) + is_top = properties.Mass() >= 1e-6 + if is_top == keep_top: + candidates.append(part) + return candidates + + +def extrude_until_rsolid( + profile: Face, + target: Solid | Sequence[Solid], + direction: Sequence[float] = (0, 0, 1), + until: str = "NEXT", +) -> Solid: + """Extrude a planar face until a target surface, including curved surfaces. + + NEXT and LAST select the nearest and farthest forward contact. PREVIOUS + and FIRST reverse the direction and select the nearest and farthest contact + behind the profile. Target surfaces must cover the profile at the contact; + an uncovered/open or disconnected output is rejected. Every target remains + a graph input, so changes to target geometry replay this feature correctly. + """ + if not isinstance(profile, Face): + raise TypeError("profile must be a Face") + targets = [target] if isinstance(target, Solid) else list(target) + if not targets: + raise ValueError("target must contain at least one Solid") + if any(not isinstance(item, Solid) for item in targets): + raise TypeError("target must be a Solid or a sequence of Solid") + mode = str(getattr(until, "name", until)).upper() + if mode not in {"NEXT", "LAST", "PREVIOUS", "FIRST"}: + raise ValueError("until must be NEXT, LAST, PREVIOUS, or FIRST") + values = _finite_vector(direction, "direction") + global_direction = get_current_cs().transform_vector(np.asarray(values)) + magnitude = float(np.linalg.norm(global_direction)) + if not math.isfinite(magnitude) or magnitude <= 1e-14: + raise ValueError("direction must be a finite nonzero vector") + axis = global_direction / magnitude + if mode in {"PREVIOUS", "FIRST"}: + axis = -axis + bound_target = make_compound_always([item.wrapped for item in targets]) + box = bounding_box(make_compound_always([profile.wrapped, bound_target])) + length = math.sqrt((box.xmax-box.xmin)**2 + (box.ymax-box.ymin)**2 + (box.zmax-box.zmin)**2) + if length <= 1e-12: + raise ValueError("Degenerate profile and target bounds") + prism = BRepPrimAPI_MakePrism(profile.wrapped, gp_Vec(*(axis * length))).Shape() + surfaces = sorted(_contact_surfaces(bound_target, prism, axis), key=lambda part: distance(part, profile.wrapped)) + nearest = mode in {"NEXT", "PREVIOUS"} + surface = surfaces[0] if nearest else surfaces[-1] + candidates = _split_on_surface(prism, surface, keep_top=nearest) + if not candidates: + raise ValueError("Extrusion produced no solid on the requested side of the target") + origin = np.asarray(tuple(center_of_mass(profile.wrapped))) + chosen = min(candidates, key=lambda part: np.dot(np.asarray(tuple(center_of_mass(part))) - origin, axis)) + if abs(volume(chosen) - volume(prism)) <= max(1e-8, abs(volume(prism))*1e-9): + raise ValueError("Target termination surface does not completely cover the extrusion profile") + if volume(chosen) <= 1e-12 or not BRepCheck_Analyzer(chosen).IsValid(): + raise ValueError("Target surface did not completely cover a valid limited extrusion") + result = _finish(profile, chosen, "make_extrude_until_rsolid", + {"direction": direction, "until": mode, "target_count": len(targets)}, [profile, *targets]) + result._apply_tag("solid.extrusion", propagate=False) + return result + + +__all__ = ("extrude_until_rsolid",) diff --git a/src/simplecadapi/operators/product.py b/src/simplecadapi/operators/product.py index b6fb1fab..fede3b48 100644 --- a/src/simplecadapi/operators/product.py +++ b/src/simplecadapi/operators/product.py @@ -131,9 +131,10 @@ def make_part_rpart( try: part = Part(part_id, body, name=name) _reserve_semantic_id("part", part.part_id) + _ensure_geo_selection_input_nodes([body]) record_operation_if_active( _OP_MAKE_PART_RPART, - _part_params(part), + {**_part_params(part), "input_refs": _serialize_shape_refs([body])}, outputs=part, input_shapes=[body], semantic_delta=_semantic_created("Part", part.part_id, part.to_dict()), diff --git a/src/simplecadapi/operators/section_features.py b/src/simplecadapi/operators/section_features.py new file mode 100644 index 00000000..9292eea8 --- /dev/null +++ b/src/simplecadapi/operators/section_features.py @@ -0,0 +1,150 @@ +"""Recorded tapered extrusions and sweeps with multiple explicit sections.""" +from __future__ import annotations + +import math +from typing import Sequence + +import numpy as np +from OCP.BRepAdaptor import BRepAdaptor_Surface +from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut +from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform +from OCP.BRepOffsetAPI import BRepOffsetAPI_MakeOffset, BRepOffsetAPI_MakePipeShell, BRepOffsetAPI_ThruSections +from OCP.BRepPrimAPI import BRepPrimAPI_MakePrism +from OCP.BRepTools import BRepTools +from OCP.GeomAbs import GeomAbs_Intersection, GeomAbs_Plane +from OCP.LocOpe import LocOpe_DPrism +from OCP.TopAbs import TopAbs_WIRE +from OCP.TopExp import TopExp_Explorer +from OCP.TopoDS import TopoDS +from OCP.gp import gp_Dir, gp_Trsf, gp_Vec + +from ._support import Face, Wire, Solid, evaluate_scalar, get_current_cs +from .deformation import _finish, _finite_vector + + +def extrude_taper_rsolid( + profile: Face, + vector: Sequence[float], + taper: float, + flip_inner: bool = True, +) -> Solid: + """Extrude a planar face by a vector, with a taper in degrees. + + Positive taper shrinks the outer section. Inner loops optionally taper in + the opposite direction. Analytic draft prisms are retained where valid; + other orientations/holes use exact offset wire sections and solid lofts. + """ + values = _finite_vector(vector, "vector") + angle = float(evaluate_scalar(taper)) + if not math.isfinite(angle) or abs(angle) >= 90: + raise ValueError("taper must be finite and between -90 and 90 degrees") + displacement = get_current_cs().transform_vector(np.asarray(values)) + length = float(np.linalg.norm(displacement)) + if length <= 1e-12: + raise ValueError("extrusion vector must be nonzero") + surface = BRepAdaptor_Surface(profile.wrapped, True) + if surface.GetType() != GeomAbs_Plane: + raise ValueError("taper extrusion requires a planar profile") + normal = np.asarray(tuple(profile.get_normal_at()), dtype=float) + outer = BRepTools.OuterWire_s(profile.wrapped) + wires = [outer] + explorer = TopExp_Explorer(profile.wrapped, TopAbs_WIRE) + while explorer.More(): + wire = TopoDS.Wire_s(explorer.Current()) + if not wire.IsSame(outer): + wires.append(wire) + explorer.Next() + if angle == 0: + shape = BRepPrimAPI_MakePrism(profile.wrapped, gp_Vec(*displacement)).Shape() + elif np.linalg.norm(displacement / length - normal) < 1e-8 and normal[2] > 0 and len(wires) == 1 and angle > 0: + shape = LocOpe_DPrism(profile.wrapped, length / math.cos(math.radians(angle)), math.radians(angle)).Shape() + else: + # Offset in the profile plane before translating the final section. + move = gp_Trsf() + move.SetTranslation(gp_Vec(*displacement)) + solids = [] + for i, wire in enumerate(wires): + # Face inner wires wind opposite to the outer boundary. Normalize + # their winding before applying the signed 2-D offset so that + # flip_inner controls geometry rather than kernel wire orientation. + if i: + wire = TopoDS.Wire_s(wire.Reversed()) + offset = -length * math.tan(math.radians(angle)) * (-1 if i and flip_inner else 1) + builder = BRepOffsetAPI_MakeOffset(wire, GeomAbs_Intersection, False) + builder.Perform(offset) + if not builder.IsDone(): + raise ValueError("taper collapses a profile loop") + offset_shape = builder.Shape() + exp = TopExp_Explorer(offset_shape, TopAbs_WIRE) + found = [] + while exp.More(): + found.append(TopoDS.Wire_s(exp.Current())) + exp.Next() + if len(found) != 1: + raise ValueError("taper changes loop connectivity") + moved = BRepBuilderAPI_Transform(found[0], move, True).Shape() + loft = BRepOffsetAPI_ThruSections(True, False) + loft.AddWire(wire) + loft.AddWire(TopoDS.Wire_s(moved)) + loft.Build() + if not loft.IsDone(): + raise ValueError("kernel could not build tapered sections") + solids.append(loft.Shape()) + shape = solids[0] + for tool in solids[1:]: + cut = BRepAlgoAPI_Cut(shape, tool) + cut.Build() + if not cut.IsDone(): + raise ValueError("kernel could not subtract tapered inner loop") + shape = cut.Shape() + return _finish(profile, shape, "make_extrude_taper_rsolid", + {"vector": vector, "taper": taper, "flip_inner": flip_inner}, [profile]) + + +def sweep_multisection_rsolid( + profiles: Sequence[Face | Wire], + path: Wire, + is_frenet: bool = False, + binormal: Sequence[float] | Wire | None = None, +) -> Solid: + """Sweep through explicit ordered section wires along a continuous path. + + Face sections use their outer boundary, as in build123d's multi-section + pipe contract. Binormal may be a direction vector or auxiliary spine. + Each supplied section and path remains a graph input for replay. + """ + sections = list(profiles) + if len(sections) < 2: + raise ValueError("multi-section sweep requires at least two sections") + builder = BRepOffsetAPI_MakePipeShell(path.wrapped) + rotate = False + if isinstance(binormal, Wire): + builder.SetMode(binormal.wrapped, True) + elif binormal is not None: + values = _finite_vector(binormal, "binormal") + direction = get_current_cs().transform_vector(np.asarray(values)) + if np.linalg.norm(direction) < 1e-12: + raise ValueError("binormal direction must be nonzero") + builder.SetMode(gp_Dir(*direction)) + rotate = True + else: + builder.SetMode(bool(is_frenet)) + for section in sections: + if not isinstance(section, (Face, Wire)): + raise TypeError("sections must be Face or Wire") + wire = BRepTools.OuterWire_s(section.wrapped) if isinstance(section, Face) else section.wrapped + builder.Add(wire, False, rotate) + builder.Build() + if not builder.IsDone() or not builder.MakeSolid(): + raise ValueError("kernel could not make a solid multi-section sweep") + inputs = [*sections, path] + params = {"profile_count": len(sections), "is_frenet": bool(is_frenet), "binormal": None} + if isinstance(binormal, Wire): + inputs.append(binormal) + params["binormal_is_wire"] = True + elif binormal is not None: + params["binormal"] = binormal + return _finish(sections[0], builder.Shape(), "make_sweep_multisection_rsolid", params, inputs) + + +__all__ = ("extrude_taper_rsolid", "sweep_multisection_rsolid") diff --git a/src/simplecadapi/operators/sketch.py b/src/simplecadapi/operators/sketch.py index b70330bd..bf23c13d 100644 --- a/src/simplecadapi/operators/sketch.py +++ b/src/simplecadapi/operators/sketch.py @@ -326,7 +326,9 @@ def add_bspline_rsketch( """Add a B-spline curve entity to a sketch. The start/end point refs link the B-spline into a closed profile - loop. Control points may be literal 2-D coordinates or point refs. + loop. A closed curve may reuse one seam ref for both endpoints. + Control points may be literal 2-D coordinates or point refs. A periodic + seam links topology without replacing the periodic curve's poles. """ try: start_ref = _resolve_sketch_target(sketch, start, expected="point") diff --git a/src/simplecadapi/ql.py b/src/simplecadapi/ql.py index 28821558..246f9fac 100644 --- a/src/simplecadapi/ql.py +++ b/src/simplecadapi/ql.py @@ -148,6 +148,15 @@ def _lookup_property(obj: Any, path: str) -> Any: gtype = _geom_type(obj) return gtype if gtype is not None else MISSING + if path.startswith("geom.bbox.") and hasattr(obj, "wrapped"): + from .kernel.ocp_properties import bounding_box + field = path.removeprefix("geom.bbox.") + names = {f"{side}.{axis}": axis + bound + for side, bound in (("min", "min"), ("max", "max")) for axis in "xyz"} + if field in names: + return float(getattr(bounding_box(obj.wrapped), names[field])) + return MISSING + if path == "geom.family": cls_name = obj.__class__.__name__.lower() if cls_name == "edge": diff --git a/src/simplecadapi/recording/serializer.py b/src/simplecadapi/recording/serializer.py index 94f0e2eb..c0e9515b 100644 --- a/src/simplecadapi/recording/serializer.py +++ b/src/simplecadapi/recording/serializer.py @@ -421,6 +421,14 @@ }, "translate_shape": {"status": "replayable", "op": "make_translate_rshape"}, "rotate_shape": {"status": "replayable", "op": "make_rotate_rshape"}, + "scale_rsolid": {"status": "replayable", "op": "make_scale_rsolid"}, + "transform_rsolid": {"status": "replayable", "op": "make_transform_rsolid"}, + "offset_rsolid": {"status": "replayable", "op": "make_offset_rsolid"}, + "boolean_rsolidlist": {"status": "replayable", "op": "make_boolean_rsolidlist"}, + "extrude_taper_rsolid": {"status": "replayable", "op": "make_extrude_taper_rsolid"}, + "sweep_multisection_rsolid": {"status": "replayable", "op": "make_sweep_multisection_rsolid"}, + "extrude_until_rsolid": {"status": "replayable", "op": "make_extrude_until_rsolid"}, + "draft_rsolid": {"status": "replayable", "op": "make_draft_rsolid"}, "mirror_shape": {"status": "replayable", "op": "make_mirror_rshape"}, "extrude_rsolid": {"status": "replayable", "op": "make_extrude_rsolid"}, "revolve_rsolid": {"status": "replayable", "op": "make_revolve_rsolid"}, @@ -597,6 +605,14 @@ "make_twisted_sweep_rsolid", "make_translate_rshape", "make_rotate_rshape", + "make_scale_rsolid", + "make_transform_rsolid", + "make_offset_rsolid", + "make_boolean_rsolidlist", + "make_extrude_taper_rsolid", + "make_sweep_multisection_rsolid", + "make_extrude_until_rsolid", + "make_draft_rsolid", "make_mirror_rshape", "make_cut_rsolid", "make_union_rsolid", @@ -2145,6 +2161,14 @@ def _ordered_input_shapes( return resolved +def _feature_input_shapes(ctx, graph, outputs, node, params): + # New features preserve order and output slots, including repeated inputs. + # Older graphs only carried distinct upstream nodes. + if "input_refs" in params: + return _ordered_input_shapes(ctx, graph, outputs, node, params) + return _all_input_outputs(ctx, outputs, node) + + def _semantic_view_origin( ctx: _ReplayContext, graph: OperationGraph, @@ -2910,7 +2934,7 @@ def _store_semantic_outputs(node, result: Any) -> None: if op_name == "make_part_rpart": ctx.require_params(node.node_id, op_name, params, ("part_id",)) - body_outputs = _input_outputs(ctx, outputs, node, 0) + body_outputs = _feature_input_shapes(ctx, graph, outputs, node, params) if body_outputs: result = ops.make_part_rpart( str(params["part_id"]), @@ -3404,8 +3428,11 @@ def _store_semantic_outputs(node, result: Any) -> None: ) source_outputs = _input_outputs(ctx, outputs, node, 0) if source_outputs: + source_slot = int(params.get("source_output_slot", 0)) + if source_slot < 0 or source_slot >= len(source_outputs): + ctx.fail(f"Graph node '{node.node_id}' selection source output slot {source_slot} is missing") result = _resolve_shape_from_geo_selector( - source_outputs[0], + source_outputs[source_slot], cast(Dict[str, Any], params["geo_selector"]), ) _store_outputs(node, result) @@ -3895,6 +3922,95 @@ def _store_semantic_outputs(node, result: Any) -> None: _store_outputs(node, result) continue + if op_name == "make_draft_rsolid": + ctx.require_params(node.node_id, op_name, params, ("angle", "selected_face_count", "plane_origin", "plane_normal")) + values = _input_outputs(ctx, outputs, node, 0) + if values: + solid = values[0] + faces = _resolve_feature_selection(ctx, node=node, solid=solid, + params=params, kind="face", outputs=outputs) + if ctx.strict and len(faces) != params["selected_face_count"]: + ctx.fail(f"Graph node '{node.node_id}' expected {params['selected_face_count']} draft faces, got {len(faces)}") + result = ops.draft_rsolid(solid=solid, faces_to_draft=faces, angle=params["angle"], + plane_origin=params["plane_origin"], plane_normal=params["plane_normal"]) + _store_outputs(node, result) + continue + + if op_name == "make_extrude_until_rsolid": + ctx.require_params(node.node_id, op_name, params, ("direction", "until", "target_count")) + count = int(params["target_count"]) + values = _feature_input_shapes(ctx, graph, outputs, node, params) + if len(values) != count + 1: + ctx.fail(f"Graph node '{node.node_id}' requires a profile and {count} ordered targets") + result = ops.extrude_until_rsolid(profile=values[0], target=values[1:], + direction=params["direction"], until=params["until"]) + _store_outputs(node, result) + continue + + if op_name == "make_extrude_taper_rsolid": + ctx.require_params(node.node_id, op_name, params, ("vector", "taper")) + input_values = _feature_input_shapes(ctx, graph, outputs, node, params) + if input_values: + result = ops.extrude_taper_rsolid(profile=input_values[0], vector=params["vector"], + taper=params["taper"], flip_inner=params.get("flip_inner", True)) + _store_outputs(node, result) + continue + + if op_name == "make_sweep_multisection_rsolid": + ctx.require_params(node.node_id, op_name, params, ("profile_count", "is_frenet")) + count = int(params["profile_count"]) + values = _feature_input_shapes(ctx, graph, outputs, node, params) + expected = count + 1 + int(bool(params.get("binormal_is_wire"))) + if len(values) != expected: + ctx.fail(f"Graph node '{node.node_id}' requires {expected} ordered sweep inputs") + binormal = values[count + 1] if params.get("binormal_is_wire") else params.get("binormal") + result = ops.sweep_multisection_rsolid(profiles=values[:count], path=values[count], + is_frenet=params["is_frenet"], binormal=binormal) + _store_outputs(node, result) + continue + + if op_name == "make_transform_rsolid": + ctx.require_params(node.node_id, op_name, params, ("matrix",)) + inputs = _feature_input_shapes(ctx, graph, outputs, node, params) + if inputs: + result = ops.transform_rsolid(solid=inputs[0], matrix=params["matrix"]) + _store_outputs(node, result) + continue + + if op_name == "make_scale_rsolid": + ctx.require_params(node.node_id, op_name, params, ("factors", "center")) + inputs = _feature_input_shapes(ctx, graph, outputs, node, params) + if inputs: + result = ops.scale_rsolid(solid=inputs[0], factors=params["factors"], center=params["center"]) + _store_outputs(node, result) + continue + + if op_name == "make_offset_rsolid": + ctx.require_params(node.node_id, op_name, params, ("amount", "removed_face_count")) + inputs = _feature_input_shapes(ctx, graph, outputs, node, params) + if inputs: + solid = inputs[0] + faces = _resolve_feature_selection(ctx, node=node, solid=solid, + params=params, kind="face", outputs=outputs) if params["removed_face_count"] else [] + if ctx.strict and len(faces) != params["removed_face_count"]: + ctx.fail(f"Graph node '{node.node_id}' expected {params['removed_face_count']} opening faces, got {len(faces)}") + result = ops.offset_rsolid(solid=solid, amount=params["amount"], openings=faces, + tolerance=params.get("tolerance", 1e-4), kind=params.get("kind", "ARC")) + _store_outputs(node, result) + continue + + if op_name == "make_boolean_rsolidlist": + ctx.require_params(node.node_id, op_name, params, + ("operation", "left_count", "right_count", "input_refs")) + inputs = _ordered_input_shapes(ctx, graph, outputs, node, params) + count, right_count = int(params["left_count"]), int(params["right_count"]) + if count < 0 or right_count < 0 or len(inputs) != count + right_count: + ctx.fail(f"Graph node '{node.node_id}' boolean input counts do not match") + result = ops.boolean_rsolidlist(left=inputs[:count], right=inputs[count:], + operation=params["operation"]) + _store_outputs(node, result) + continue + if op_name == "make_extrude_rsolid": ctx.require_params( node.node_id, op_name, params, ("direction", "distance") diff --git a/src/simplecadapi/sketch.py b/src/simplecadapi/sketch.py index 2cc907ba..4e7200d7 100644 --- a/src/simplecadapi/sketch.py +++ b/src/simplecadapi/sketch.py @@ -519,8 +519,10 @@ def add_bspline( """Add a B-spline whose poles participate in sketch solving. Control points may be literal 2-D coordinates or refs to points in - this sketch. The first and last poles always share the declared - start/end point entities. + this sketch. For nonperiodic curves the first and last poles share + the declared start/end point entities. A closed curve may use one + seam point for both endpoints; a periodic seam does not replace its + control poles, which generally lie away from the seam. """ from .operators.geometry import ( _normalize_bspline_knots, @@ -529,8 +531,6 @@ def add_bspline( start_id = self.resolve_point_id(start) end_id = self.resolve_point_id(end) - if start_id == end_id: - raise ValueError("A sketch bspline requires two distinct endpoint refs") if isinstance(degree, bool) or int(degree) != degree: raise ValueError("degree must be an integer") degree_value = int(degree) @@ -591,18 +591,19 @@ def resolved_control_point(point: Any) -> List[float]: end_entity = self.entities[end_id] start_point = [_as_float(start_entity.data["x"]), _as_float(start_entity.data["y"])] end_point = [_as_float(end_entity.data["x"]), _as_float(end_entity.data["y"])] - if isinstance(normalized_cps[0], Mapping): + if not periodic and isinstance(normalized_cps[0], Mapping): if normalized_cps[0]["point_id"] != start_id: raise ValueError("The first B-spline control-point ref must match start") - else: + elif not periodic: normalized_cps[0] = start_point - if isinstance(normalized_cps[-1], Mapping): + if not periodic and isinstance(normalized_cps[-1], Mapping): if normalized_cps[-1]["point_id"] != end_id: raise ValueError("The last B-spline control-point ref must match end") - else: + elif not periodic: normalized_cps[-1] = end_point - resolved_cps[0] = start_point - resolved_cps[-1] = end_point + if not periodic: + resolved_cps[0] = start_point + resolved_cps[-1] = end_point self._add_entity( SketchEntity( entity_id, diff --git a/src/simplecadapi/sketch_solver/py_slvs_backend.py b/src/simplecadapi/sketch_solver/py_slvs_backend.py index c364789f..1a7c6348 100644 --- a/src/simplecadapi/sketch_solver/py_slvs_backend.py +++ b/src/simplecadapi/sketch_solver/py_slvs_backend.py @@ -234,9 +234,9 @@ def _add_bspline_entity( if isinstance(point, Mapping) else None ) - if point_id is None and index == 0: + if point_id is None and index == 0 and not data.get("periodic", False): point_id = str(data["start"]) - elif point_id is None and index == len(raw_points) - 1: + elif point_id is None and index == len(raw_points) - 1 and not data.get("periodic", False): point_id = str(data["end"]) if point_id is not None: endpoint = self.point_handles[str(point_id)] diff --git a/src/simplecadapi/topology/model.py b/src/simplecadapi/topology/model.py index 65635103..c88e8b7b 100644 --- a/src/simplecadapi/topology/model.py +++ b/src/simplecadapi/topology/model.py @@ -648,6 +648,8 @@ def _node_display_category(op: str) -> str: "mirror", "make_translate_rshape", "make_rotate_rshape", + "make_scale_rsolid", + "make_transform_rsolid", "make_mirror_rshape", }: return "transform" @@ -664,6 +666,9 @@ def _node_display_category(op: str) -> str: "make_loft_rsolid", "make_sweep_rsolid", "make_twisted_sweep_rsolid", + "make_extrude_taper_rsolid", + "make_extrude_until_rsolid", + "make_sweep_multisection_rsolid", }: return "feature" if op in { @@ -673,6 +678,8 @@ def _node_display_category(op: str) -> str: "make_fillet_rsolid", "make_chamfer_rsolid", "make_shell_rsolid", + "make_offset_rsolid", + "make_draft_rsolid", }: return "detail" if op.startswith("make_"): diff --git a/test/build123d_traces/README.md b/test/build123d_traces/README.md new file mode 100644 index 00000000..bb03c7e8 --- /dev/null +++ b/test/build123d_traces/README.md @@ -0,0 +1,18 @@ +# Portable build123d feature traces + +These fixtures contain the actual operation inputs captured from six of the +50 build123d examples supplied for the converter: lines and arcs, a selected +circular fillet, a mirrored profile, one closed font glyph with a hole, and a +nonplanar spring sweep, and a spherical cut/fillet followed by nonuniform scale. +The glyph is feature `s3` of the text example; the affine case retains the first +eight features of the keycap example. Other traces retain their entire history. + +The tests require SimpleCADAPI but do not import build123d, download source +programs, load result BReps, or use paths outside the repository. Curve data +contains exact analytic geometry or B-spline poles, knots, multiplicities, +and weights; it is not a mesh or a fitted final-body snapshot. + +Reference volumes use OCCT's adaptive Gauss–Kronrod integration with +`eps=1e-9` and B-spline span splitting. Original non-adaptive volumes remain +as diagnostic data because they differ materially on closed rational curves. +Each fixture records its build123d and source-kernel versions. diff --git a/test/build123d_traces/affine_trimmed_sphere.trace.json b/test/build123d_traces/affine_trimmed_sphere.trace.json new file mode 100644 index 00000000..1ed6153d --- /dev/null +++ b/test/build123d_traces/affine_trimmed_sphere.trace.json @@ -0,0 +1,820 @@ +{ + "schema_version": "1.0", + "steps": [ + { + "id": "s1", + "op": "extrude_taper", + "inputs": [], + "parameters": { + "direction": [ + 0.0, + 0.0, + 10.0 + ], + "taper": 15, + "flip_inner": true + }, + "source": "Solid.extrude_taper", + "result": { + "volume": 2371.1119335472795, + "volume_gk": 2371.1119335472795, + "area": 1118.2335726410245, + "default_volume": 2371.11193354728, + "bbox": [ + -9.0, + -9.0, + 0.0, + 9.0, + 9.0, + 10.000000000000005 + ], + "solid_count": 1 + }, + "profile": { + "kind": "face", + "origin": [ + -2.0816681711721685e-17, + -2.4671622769447924e-16, + 0.0 + ], + "x_dir": [ + 1.0, + 0.0, + -0.0 + ], + "y_dir": [ + -0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + 1.0 + ], + "wires": [ + { + "edges": [ + { + "kind": "line", + "start": [ + -9.0, + 9.0, + 0.0 + ], + "end": [ + -9.0, + -9.0, + 0.0 + ], + "parameter_range": [ + -9.0, + 9.0 + ], + "reversed": true + }, + { + "kind": "line", + "start": [ + -9.0, + -9.0, + 0.0 + ], + "end": [ + 9.0, + -9.0, + 0.0 + ], + "parameter_range": [ + -9.0, + 9.0 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + 9.0, + -9.0, + 0.0 + ], + "end": [ + 9.0, + 9.0, + 0.0 + ], + "parameter_range": [ + -9.0, + 9.0 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + 9.0, + 9.0, + 0.0 + ], + "end": [ + -9.0, + 9.0, + 0.0 + ], + "parameter_range": [ + -9.0, + 9.0 + ], + "reversed": true + } + ], + "closed": true + } + ] + } + }, + { + "id": "s2", + "op": "sphere", + "inputs": [], + "parameters": { + "radius": 40, + "plane": { + "origin": [ + 0.0, + 0.0, + 0.0 + ], + "x_dir": [ + 1.0, + 0.0, + -0.0 + ], + "y_dir": [ + -0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + 1.0 + ] + }, + "angle1": -90, + "angle2": 90, + "angle3": 360 + }, + "source": "Solid.make_sphere", + "result": { + "volume": 268082.57310632826, + "volume_gk": 268082.57310632826, + "area": 20106.192982974666, + "default_volume": 268082.5731063291, + "bbox": [ + -40.0, + -40.0, + -40.0, + 40.0, + 40.0, + 40.0 + ], + "solid_count": 1 + } + }, + { + "id": "s3", + "op": "transform", + "inputs": [ + "s2" + ], + "parameters": { + "loc": { + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + -0.0 + ], + [ + 0.0, + 1.0, + 0.0, + -0.0 + ], + [ + 0.0, + 0.0, + 1.0, + -0.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "method": "move", + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + -0.0 + ], + [ + 0.0, + 1.0, + 0.0, + -0.0 + ], + [ + 0.0, + 0.0, + 1.0, + -0.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "source": "Shape.move", + "result": { + "volume": 268082.57310632826, + "volume_gk": 268082.57310632826, + "area": 20106.192982974666, + "default_volume": 268082.5731063291, + "bbox": [ + -40.0, + -40.0, + -40.0, + 40.0, + 40.0, + 40.0 + ], + "solid_count": 1 + } + }, + { + "id": "s4", + "op": "transform", + "inputs": [ + "s3" + ], + "parameters": { + "loc": { + "matrix": [ + [ + 1.0, + -0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 2.220446049250313e-16, + -1.0, + 0.0 + ], + [ + 0.0, + 1.0, + 2.220446049250313e-16, + 0.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "method": "moved", + "matrix": [ + [ + 1.0, + -0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 2.220446049250313e-16, + -1.0, + 0.0 + ], + [ + 0.0, + 1.0, + 2.220446049250313e-16, + 0.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "source": "Shape.moved", + "result": { + "volume": 268082.5731063284, + "volume_gk": 268082.5731063284, + "area": 20106.192982974666, + "default_volume": 268082.5731063291, + "bbox": [ + -40.0, + -40.0, + -40.0, + 40.0, + 40.0, + 40.0 + ], + "solid_count": 1 + } + }, + { + "id": "s5", + "op": "transform", + "inputs": [ + "s4" + ], + "parameters": { + "loc": { + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 1.0, + 0.0, + -3.0 + ], + [ + 0.0, + 0.0, + 1.0, + 47.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "method": "moved", + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 1.0, + 0.0, + -3.0 + ], + [ + 0.0, + 0.0, + 1.0, + 47.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "source": "Shape.moved", + "result": { + "volume": 268082.5731063284, + "volume_gk": 268082.5731063284, + "area": 20106.192982974666, + "default_volume": 268082.5731063291, + "bbox": [ + -40.0, + -43.0, + 7.0, + 40.0, + 37.0, + 87.0 + ], + "solid_count": 1 + } + }, + { + "id": "s6", + "op": "cut", + "inputs": [ + "s1", + "s5" + ], + "parameters": {}, + "source": "Shape.cut", + "result": { + "volume": 1929.8444343829303, + "volume_gk": 1929.8444343829303, + "area": 1035.6152278365398, + "default_volume": 1929.844434382934, + "bbox": [ + -9.0, + -9.0, + 0.0, + 9.0, + 9.0, + 8.756864140153603 + ], + "solid_count": 1 + } + }, + { + "id": "s7", + "op": "fillet", + "inputs": [ + "s6" + ], + "parameters": { + "radius": 1 + }, + "source": "Mixin3D.fillet", + "result": { + "volume": 1914.6009359753375, + "volume_gk": 1914.6009359753375, + "area": 1002.7137487227009, + "default_volume": 1914.6009359753382, + "bbox": [ + -9.000000100000001, + -9.000000100000001, + -1e-07, + 9.000000100000001, + 9.000000100000001, + 8.441500309937386 + ], + "solid_count": 1 + }, + "selection": [ + { + "kind": "edge", + "geom_type": "LINE", + "center": [ + -7.955513473192318, + -7.955513473192318, + 3.898076785867421 + ], + "bbox": [ + -9.0, + -9.0, + 0.0, + -6.911026946384637, + -6.911026946384637, + 7.796153571734842 + ], + "length": 8.337123445861655, + "start": [ + -6.911026946384637, + -6.911026946384637, + 7.796153571734842 + ], + "mid": [ + -7.955513473192318, + -7.955513473192318, + 3.898076785867421 + ], + "end": [ + -9.0, + -9.0, + 0.0 + ], + "index": 4 + }, + { + "kind": "edge", + "geom_type": "LINE", + "center": [ + 7.955513473192318, + -7.955513473192318, + 3.898076785867421 + ], + "bbox": [ + 6.911026946384637, + -9.0, + 0.0, + 9.0, + -6.911026946384637, + 7.796153571734842 + ], + "length": 8.337123445861655, + "start": [ + 6.911026946384637, + -6.911026946384637, + 7.796153571734842 + ], + "mid": [ + 7.955513473192318, + -7.955513473192318, + 3.898076785867421 + ], + "end": [ + 9.0, + -9.0, + 0.0 + ], + "index": 7 + }, + { + "kind": "edge", + "geom_type": "LINE", + "center": [ + -7.826802662708394, + 7.826802662708394, + 4.378432070076798 + ], + "bbox": [ + -9.0, + 6.653605325416787, + 0.0, + -6.653605325416787, + 9.0, + 8.756864140153596 + ], + "length": 9.364497077095645, + "start": [ + -9.0, + 9.0, + 0.0 + ], + "mid": [ + -7.826802662708394, + 7.826802662708394, + 4.378432070076798 + ], + "end": [ + -6.653605325416787, + 6.653605325416787, + 8.756864140153596 + ], + "index": 6 + }, + { + "kind": "edge", + "geom_type": "LINE", + "center": [ + 7.826802662708394, + 7.826802662708394, + 4.378432070076798 + ], + "bbox": [ + 6.653605325416787, + 6.653605325416787, + 0.0, + 9.0, + 9.0, + 8.756864140153596 + ], + "length": 9.364497077095645, + "start": [ + 6.653605325416787, + 6.653605325416787, + 8.756864140153596 + ], + "mid": [ + 7.826802662708394, + 7.826802662708394, + 4.378432070076798 + ], + "end": [ + 9.0, + 9.0, + 0.0 + ], + "index": 9 + }, + { + "kind": "edge", + "geom_type": "CIRCLE", + "center": [ + 2.2364273360068107e-14, + -7.016130216452036, + 7.40390282780167 + ], + "bbox": [ + -6.911026946384598, + -7.068763296161196, + 7.207473500168263, + 6.911026946384642, + -6.911026946384634, + 7.796153571734848 + ], + "length": 13.893601237415288, + "start": [ + -6.911026946384598, + -6.911026946384636, + 7.796153571734841 + ], + "mid": [ + 2.2373044540339126e-14, + -7.068763296161196, + 7.207473500168263 + ], + "end": [ + 6.911026946384642, + -6.911026946384634, + 7.796153571734848 + ], + "index": 8 + }, + { + "kind": "edge", + "geom_type": "CIRCLE", + "center": [ + -6.882861213849936, + -0.10022652368490893, + 7.9012695165867335 + ], + "bbox": [ + -6.960821167729055, + -6.911026946384645, + 7.610319007754136, + -6.653605325416786, + 6.6536053254167875, + 8.756864140153603 + ], + "length": 13.667946481986268, + "start": [ + -6.653605325416786, + 6.6536053254167875, + 8.756864140153603 + ], + "mid": [ + -6.933207795109661, + -0.08596340420454629, + 7.713373517338049 + ], + "end": [ + -6.911026946384634, + -6.911026946384645, + 7.796153571734848 + ], + "index": 5 + }, + { + "kind": "edge", + "geom_type": "CIRCLE", + "center": [ + 6.882861213849936, + -0.10022652368489449, + 7.901269516586735 + ], + "bbox": [ + 6.653605325416786, + -6.911026946384631, + 7.610319007754136, + 6.960821167729055, + 6.653605325416802, + 8.756864140153603 + ], + "length": 13.667946481986268, + "start": [ + 6.911026946384634, + -6.911026946384631, + 7.796153571734848 + ], + "mid": [ + 6.933207795109661, + -0.08596340420453208, + 7.713373517338049 + ], + "end": [ + 6.653605325416786, + 6.653605325416802, + 8.756864140153603 + ], + "index": 10 + }, + { + "kind": "edge", + "geom_type": "CIRCLE", + "center": [ + -4.503045217372866e-14, + 6.74972397417161, + 8.398144459445728 + ], + "bbox": [ + -6.653605325416833, + 6.653605325416785, + 8.218533741391056, + 6.653605325416744, + 6.7978505210263345, + 8.756864140153603 + ], + "length": 13.369366777347004, + "start": [ + 6.653605325416744, + 6.653605325416788, + 8.756864140153588 + ], + "mid": [ + -4.531965428549345e-14, + 6.7978505210263345, + 8.218533741391056 + ], + "end": [ + -6.653605325416833, + 6.653605325416785, + 8.756864140153603 + ], + "index": 11 + } + ] + }, + { + "id": "s8", + "op": "transform", + "inputs": [ + "s7" + ], + "parameters": { + "factor": [ + 0.925, + 0.925, + 0.85 + ], + "about": [ + 0.0, + 0.0, + 0.0 + ], + "method": "scale" + }, + "source": "Shape.scale", + "result": { + "volume": 1392.4533674204192, + "volume_gk": 1392.4533674204192, + "area": 826.3818860013073, + "default_volume": 1392.4533674401873, + "bbox": [ + -8.325000100000002, + -8.325000100000002, + -1e-07, + 8.325000100000002, + 8.325000100000002, + 7.175275363446779 + ], + "solid_count": 1 + } + } + ], + "result_refs": [ + "s8" + ], + "b3d_status": "ok", + "b3d_volume": 1392.4533674204192, + "b3d_bbox": [ + -8.325000100000002, + -8.325000100000002, + -1e-07, + 8.325000100000002, + 8.325000100000002, + 7.175275363446779 + ], + "solid_count": 1, + "unsupported": [], + "error": "", + "b3d_default_volume": 1392.4533674401873, + "b3d_volume_gk": 1392.4533674204192, + "b3d_valid": true, + "b3d_area": 826.3818860013073, + "source_file": "models/45_key_cap.py", + "source_sha256": "3e3683ba02aff7a4d0baca83532875541030b095d2e46b4de7307437e384a6b4", + "build123d_version": "0.13.0", + "stem": "affine_trimmed_sphere", + "source_metadata": { + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/key_cap.py", + "source_sha256": "0e3b3e77b88e488ef093b308415072dddded3e971e72081bf1c0a51ad9ce2e73", + "export_options": { + "precision_mode": "AVERAGE", + "write_pcurves": true + } + }, + "extraction_note": "First eight real feature operations of model 45, through affine scale; source provenance retained." +} diff --git a/test/build123d_traces/closed_text_outline.trace.json b/test/build123d_traces/closed_text_outline.trace.json new file mode 100644 index 00000000..f44eb7fc --- /dev/null +++ b/test/build123d_traces/closed_text_outline.trace.json @@ -0,0 +1,311 @@ +{ + "schema_version": "1.0", + "steps": [ + { + "id": "s3", + "op": "extrude", + "inputs": [], + "parameters": { + "direction": [ + 0.0, + 0.0, + 4.0 + ] + }, + "source": "Solid.extrude", + "result": { + "volume": 289.73641490428105, + "volume_gk": 289.73641490428105, + "default_volume": 290.6612252204212, + "bbox": [ + 14.874267428125, + -7.713174450168028e-15, + 4.9999999, + 27.020263721875, + 13.549804887499992, + 9.0000001 + ], + "solid_count": 1 + }, + "profile": { + "kind": "face", + "origin": [ + 20.952972409981427, + 6.772877390140605, + 5.0 + ], + "x_dir": [ + 1.0, + 0.0, + -0.0 + ], + "y_dir": [ + -0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + 1.0 + ], + "wires": [ + { + "edges": [ + { + "kind": "bspline", + "start": [ + 16.876220653125, + 12.109375099999992, + 5.0 + ], + "end": [ + 16.876220653125, + 12.109375099999992, + 5.0 + ], + "parameter_range": [ + 0.0, + 6.5628065631728365 + ], + "reversed": false, + "degree": 2, + "poles": [ + [ + 16.876220653125, + 12.109375099999992, + 5.0 + ], + [ + 14.874267528125, + 10.375976662499992, + 5.0 + ], + [ + 14.874267528125, + 3.4912110374999923, + 5.0 + ], + [ + 18.231201121875, + 9.999999228682555e-08, + 5.0 + ], + [ + 22.650146434375, + 9.999999228682555e-08, + 5.0 + ], + [ + 25.518798778125, + 1.5869141624999923, + 5.0 + ], + [ + 27.020263621875, + 4.455566506249992, + 5.0 + ], + [ + 27.020263621875, + 10.046386818749992, + 5.0 + ], + [ + 23.626708934375, + 13.549804787499992, + 5.0 + ], + [ + 18.548583934375, + 13.549804787499992, + 5.0 + ], + [ + 16.876220653125, + 12.109375099999992, + 5.0 + ] + ], + "weights": [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ], + "knots": [ + 0.0, + 1.0, + 1.911864406779661, + 2.823728813559322, + 3.39211066352512, + 3.9604925134909177, + 4.5288743634567155, + 5.230340744146212, + 5.931807124835709, + 6.5628065631728365 + ], + "multiplicities": [ + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 3 + ], + "periodic": false + } + ], + "closed": true + }, + { + "edges": [ + { + "kind": "bspline", + "start": [ + 17.132568309375, + 6.774902443749992, + 5.0 + ], + "end": [ + 17.132568309375, + 6.774902443749992, + 5.0 + ], + "parameter_range": [ + 0.0, + 8.16675617962079 + ], + "reversed": false, + "degree": 2, + "poles": [ + [ + 17.132568309375, + 6.774902443749992, + 5.0 + ], + [ + 17.132568309375, + 9.265136818749992, + 5.0 + ], + [ + 19.305419871875, + 11.730957131249992, + 5.0 + ], + [ + 22.576904246875, + 11.730957131249992, + 5.0 + ], + [ + 24.761962840625, + 9.252929787499992, + 5.0 + ], + [ + 24.761962840625, + 4.296875099999992, + 5.0 + ], + [ + 22.589111278125, + 1.8066407249999923, + 5.0 + ], + [ + 19.305419871875, + 1.8066407249999923, + 5.0 + ], + [ + 17.132568309375, + 4.284668068749992, + 5.0 + ], + [ + 17.132568309375, + 6.774902443749992, + 5.0 + ] + ], + "weights": [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ], + "knots": [ + 0.0, + 1.0, + 2.0, + 2.985185185185185, + 3.97037037037037, + 5.015566835871404, + 6.060763301372438, + 7.113759740496614, + 8.16675617962079 + ], + "multiplicities": [ + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 3 + ], + "periodic": false + } + ], + "closed": true + } + ] + } + } + ], + "result_refs": [ + "s3" + ], + "b3d_status": "ok", + "b3d_volume": 289.73641490428105, + "b3d_volume_gk": 289.73641490428105, + "b3d_default_volume": 290.6612252204212, + "b3d_bbox": [ + 14.874267428125, + -7.713174450168028e-15, + 4.9999999, + 27.020263721875, + 13.549804887499992, + 9.0000001 + ], + "solid_count": 1, + "unsupported": [], + "fixture_provenance": { + "source_stem": "34_embossed_debossed_text", + "source_feature": "s3", + "build123d_version": "0.13.0", + "source_kernel": "8.0.1.1", + "reference_volume_method": "Gauss-Kronrod, eps=1e-9, use_span=True" + } +} diff --git a/test/build123d_traces/face_mirror.trace.json b/test/build123d_traces/face_mirror.trace.json new file mode 100644 index 00000000..8dd7d189 --- /dev/null +++ b/test/build123d_traces/face_mirror.trace.json @@ -0,0 +1,249 @@ +{ + "schema_version": "1.0", + "steps": [ + { + "id": "s1", + "op": "extrude", + "inputs": [], + "parameters": { + "direction": [ + 0.0, + 0.0, + 20.0 + ] + }, + "source": "Solid.extrude", + "result": { + "volume": 42797.5432332819, + "volume_gk": 42797.5432332819, + "default_volume": 42797.54323328191, + "bbox": [ + -24.270509831248425, + -28.53169548885461, + 0.0, + 30.0, + 28.531695488854606, + 20.0 + ], + "solid_count": 1 + }, + "profile": { + "kind": "face", + "origin": [ + -9.23053696217674e-16, + 0.0, + 0.0 + ], + "x_dir": [ + 1.0, + 0.0, + -0.0 + ], + "y_dir": [ + -0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + 1.0 + ], + "wires": [ + { + "edges": [ + { + "kind": "line", + "start": [ + 30.0, + 0.0, + 0.0 + ], + "end": [ + 9.270509831248427, + 28.531695488854602, + 0.0 + ], + "parameter_range": [ + 0.0, + 35.26711513754839 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + 9.270509831248424, + 28.531695488854606, + 0.0 + ], + "end": [ + -24.27050983124842, + 17.633557568774197, + 0.0 + ], + "parameter_range": [ + 0.0, + 35.26711513754839 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + -24.27050983124842, + 17.633557568774197, + 0.0 + ], + "end": [ + -24.270509831248425, + -17.63355756877419, + 0.0 + ], + "parameter_range": [ + 0.0, + 35.26711513754839 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + -24.270509831248425, + -17.63355756877419, + 0.0 + ], + "end": [ + 9.270509831248418, + -28.53169548885461, + 0.0 + ], + "parameter_range": [ + 0.0, + 35.26711513754839 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + 9.270509831248416, + -28.53169548885461, + 0.0 + ], + "end": [ + 29.999999999999996, + 3.548257364643738e-16, + 0.0 + ], + "parameter_range": [ + 0.0, + 35.267115137548394 + ], + "reversed": false + } + ], + "closed": true + } + ] + } + }, + { + "id": "s2", + "op": "transform", + "inputs": [ + "s1" + ], + "parameters": { + "mirror_plane": { + "origin": [ + -7.500000000000003, + -23.0826265288144, + 10.0 + ], + "x_dir": [ + 0.9510565162951525, + -0.30901699437495084, + 0.0 + ], + "y_dir": [ + -0.0, + 0.0, + 1.0 + ], + "normal": [ + -0.30901699437495084, + -0.9510565162951525, + -0.0 + ] + }, + "method": "mirror" + }, + "source": "Shape.mirror", + "result": { + "volume": 42797.54323328192, + "volume_gk": 42797.54323328192, + "default_volume": 42797.54323328192, + "bbox": [ + -45.00000000000017, + -74.69694854648331, + 0.0, + 9.270509831248383, + -17.633557568774084, + 20.0 + ], + "solid_count": 1 + } + }, + { + "id": "s3", + "op": "union", + "inputs": [ + "s1", + "s2" + ], + "parameters": { + "glue": false, + "tol": null + }, + "source": "Shape.fuse", + "result": { + "volume": 85595.08646656375, + "volume_gk": 85595.08646656375, + "default_volume": 85595.08646656378, + "bbox": [ + -45.00000000000017, + -74.69694854648331, + 0.0, + 30.0, + 28.531695488854606, + 20.0 + ], + "solid_count": 1 + } + } + ], + "result_refs": [ + "s3" + ], + "b3d_volume": 85595.08646656375, + "b3d_volume_gk": 85595.08646656375, + "b3d_default_volume": 85595.08646656378, + "b3d_bbox": [ + -45.00000000000017, + -74.69694854648331, + 0.0, + 30.0, + 28.531695488854606, + 20.0 + ], + "solid_count": 1, + "b3d_status": "ok", + "unsupported": [], + "fixture_provenance": { + "source_stem": "17_face_mirror", + "build123d_version": "0.13.0", + "source_kernel": "8.0.1.1", + "reference_volume_method": "Gauss-Kronrod, eps=1e-9, use_span=True" + } +} diff --git a/test/build123d_traces/filleted_hole.trace.json b/test/build123d_traces/filleted_hole.trace.json new file mode 100644 index 00000000..713a9184 --- /dev/null +++ b/test/build123d_traces/filleted_hole.trace.json @@ -0,0 +1,365 @@ +{ + "schema_version": "1.0", + "steps": [ + { + "id": "s1", + "op": "box", + "inputs": [], + "parameters": { + "length": 80.0, + "width": 60.0, + "height": 10.0, + "plane": { + "origin": [ + 0.0, + 0.0, + 0.0 + ], + "x_dir": [ + 1.0, + 0.0, + -0.0 + ], + "y_dir": [ + -0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + 1.0 + ] + } + }, + "source": "Solid.make_box", + "result": { + "volume": 47999.99999999999, + "volume_gk": 47999.99999999999, + "default_volume": 48000.0, + "bbox": [ + 0.0, + 0.0, + 0.0, + 80.0, + 60.0, + 10.0 + ], + "solid_count": 1 + } + }, + { + "id": "s2", + "op": "transform", + "inputs": [ + "s1" + ], + "parameters": { + "loc": { + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + -40.0 + ], + [ + 0.0, + 1.0, + 0.0, + -30.0 + ], + [ + 0.0, + 0.0, + 1.0, + -5.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "method": "move", + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + -40.0 + ], + [ + 0.0, + 1.0, + 0.0, + -30.0 + ], + [ + 0.0, + 0.0, + 1.0, + -5.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "source": "Shape.move", + "result": { + "volume": 47999.99999999999, + "volume_gk": 47999.99999999999, + "default_volume": 48000.0, + "bbox": [ + -40.0, + -30.0, + -5.0, + 40.0, + 30.0, + 5.0 + ], + "solid_count": 1 + } + }, + { + "id": "s3", + "op": "cylinder", + "inputs": [], + "parameters": { + "radius": 15.0, + "height": 200.9975124224178, + "plane": { + "origin": [ + 0.0, + 0.0, + 100.4987562112089 + ], + "x_dir": [ + -1.0, + 0.0, + -0.0 + ], + "y_dir": [ + 0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + -1.0 + ] + }, + "angle": 360 + }, + "source": "Solid.make_cylinder", + "result": { + "volume": 142076.76939362014, + "volume_gk": 142076.76939362014, + "default_volume": 142076.76939362046, + "bbox": [ + -15.0, + -15.0, + -100.4987562112089, + 15.0, + 15.0, + 100.4987562112089 + ], + "solid_count": 1 + } + }, + { + "id": "s4", + "op": "transform", + "inputs": [ + "s3" + ], + "parameters": { + "loc": { + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + -0.0 + ], + [ + 0.0, + 1.0, + 0.0, + -0.0 + ], + [ + 0.0, + 0.0, + 1.0, + -0.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "method": "move", + "matrix": [ + [ + 1.0, + 0.0, + 0.0, + -0.0 + ], + [ + 0.0, + 1.0, + 0.0, + -0.0 + ], + [ + 0.0, + 0.0, + 1.0, + -0.0 + ], + [ + 0.0, + 0.0, + 0.0, + 1.0 + ] + ] + }, + "source": "Shape.move", + "result": { + "volume": 142076.76939362014, + "volume_gk": 142076.76939362014, + "default_volume": 142076.76939362046, + "bbox": [ + -15.0, + -15.0, + -100.4987562112089, + 15.0, + 15.0, + 100.4987562112089 + ], + "solid_count": 1 + } + }, + { + "id": "s5", + "op": "cut", + "inputs": [ + "s2", + "s4" + ], + "parameters": {}, + "source": "Shape.cut", + "result": { + "volume": 40931.41652942296, + "volume_gk": 40931.41652942296, + "default_volume": 40931.41652942296, + "bbox": [ + -40.0, + -30.0, + -5.0, + 40.0, + 30.0, + 5.0 + ], + "solid_count": 1 + } + }, + { + "id": "s6", + "op": "fillet", + "inputs": [ + "s5" + ], + "parameters": { + "radius": 2 + }, + "source": "Mixin3D.fillet", + "result": { + "volume": 40848.104058581375, + "volume_gk": 40848.104058581375, + "default_volume": 40848.10405858136, + "bbox": [ + -40.0, + -30.0, + -5.0, + 40.0, + 30.0, + 5.0 + ], + "solid_count": 1 + }, + "selection": [ + { + "kind": "edge", + "geom_type": "CIRCLE", + "center": [ + -7.0682404105834e-14, + -4.637201104937301e-16, + 4.999999999999999 + ], + "bbox": [ + -15.0, + -15.0, + 5.0, + 15.0, + 15.0, + 5.0 + ], + "length": 94.2477796076938, + "start": [ + -15.0, + -1.699661669294394e-14, + 5.0 + ], + "mid": [ + 15.0, + 8.49830834647197e-15, + 5.0 + ], + "end": [ + -15.0, + 0.0, + 5.0 + ], + "index": 9 + } + ] + } + ], + "result_refs": [ + "s6" + ], + "b3d_volume": 40848.104058581375, + "b3d_volume_gk": 40848.104058581375, + "b3d_default_volume": 40848.10405858136, + "b3d_bbox": [ + -40.0, + -30.0, + -5.0, + 40.0, + 30.0, + 5.0 + ], + "solid_count": 1, + "b3d_status": "ok", + "unsupported": [], + "fixture_provenance": { + "source_stem": "10_filleted_hole", + "build123d_version": "0.13.0", + "source_kernel": "8.0.1.1", + "reference_volume_method": "Gauss-Kronrod, eps=1e-9, use_span=True" + } +} diff --git a/test/build123d_traces/lines_and_arcs.trace.json b/test/build123d_traces/lines_and_arcs.trace.json new file mode 100644 index 00000000..e238548d --- /dev/null +++ b/test/build123d_traces/lines_and_arcs.trace.json @@ -0,0 +1,178 @@ +{ + "schema_version": "1.0", + "steps": [ + { + "id": "s1", + "op": "extrude", + "inputs": [], + "parameters": { + "direction": [ + 0.0, + 0.0, + 10.0 + ] + }, + "source": "Solid.extrude", + "result": { + "volume": 69504.67164903213, + "volume_gk": 69504.67164903213, + "default_volume": 69504.6716490322, + "bbox": [ + 0.0, + 0.0, + 0.0, + 80.0, + 95.31128874149275, + 10.0 + ], + "solid_count": 1 + }, + "profile": { + "kind": "face", + "origin": [ + 40.0, + 43.87364956936529, + 0.0 + ], + "x_dir": [ + 1.0, + 0.0, + -0.0 + ], + "y_dir": [ + -0.0, + 1.0, + 0.0 + ], + "normal": [ + 0.0, + 0.0, + 1.0 + ], + "wires": [ + { + "edges": [ + { + "kind": "line", + "start": [ + 0.0, + 0.0, + 0.0 + ], + "end": [ + 80.0, + 0.0, + 0.0 + ], + "parameter_range": [ + 0.0, + 80.0 + ], + "reversed": false + }, + { + "kind": "line", + "start": [ + 80.0, + 0.0, + 0.0 + ], + "end": [ + 80.0, + 60.0, + 0.0 + ], + "parameter_range": [ + 0.0, + 60.0 + ], + "reversed": false + }, + { + "kind": "arc", + "mid": [ + 40.00000000000001, + 95.31128874149275, + 0.0 + ], + "start": [ + 80.0, + 60.0, + 0.0 + ], + "end": [ + 0.0, + 60.00000000000001, + 0.0 + ], + "parameter_range": [ + 0.0, + 2.89288266449627 + ], + "reversed": false, + "center": [ + 40.0, + 55.0, + 0.0 + ], + "radius": 40.311288741492746, + "normal": [ + 0.0, + 0.0, + 1.0 + ], + "x_dir": [ + 0.9922778767136677, + 0.12403473458920847, + -0.0 + ] + }, + { + "kind": "line", + "start": [ + 0.0, + 60.0, + 0.0 + ], + "end": [ + 0.0, + 0.0, + 0.0 + ], + "parameter_range": [ + 0.0, + 60.0 + ], + "reversed": false + } + ], + "closed": true + } + ] + } + } + ], + "result_refs": [ + "s1" + ], + "b3d_volume": 69504.67164903213, + "b3d_volume_gk": 69504.67164903213, + "b3d_default_volume": 69504.6716490322, + "b3d_bbox": [ + 0.0, + 0.0, + 0.0, + 80.0, + 95.31128874149275, + 10.0 + ], + "solid_count": 1, + "b3d_status": "ok", + "unsupported": [], + "fixture_provenance": { + "source_stem": "04_lines_and_arcs_profile", + "build123d_version": "0.13.0", + "source_kernel": "8.0.1.1", + "reference_volume_method": "Gauss-Kronrod, eps=1e-9, use_span=True" + } +} diff --git a/test/build123d_traces/spring.trace.json b/test/build123d_traces/spring.trace.json new file mode 100644 index 00000000..5341a7db --- /dev/null +++ b/test/build123d_traces/spring.trace.json @@ -0,0 +1,1350 @@ +{ + "schema_version": "1.0", + "steps": [ + { + "id": "s1", + "op": "sweep", + "inputs": [], + "parameters": { + "make_solid": true, + "is_frenet": false, + "mode": null, + "transition": "TRANSFORMED" + }, + "source": "Solid.sweep", + "result": { + "volume": 35.642805167823504, + "volume_gk": 35.642805167823504, + "default_volume": 35.642681367230885, + "bbox": [ + -2.300012799317609, + -2.3000127993174146, + -0.2990547016451006, + 2.3000127993175012, + 2.3000127993174946, + 10.299054701644959 + ], + "solid_count": 1 + }, + "profile": { + "kind": "face", + "origin": [ + 2.0, + 6.652720096874938e-16, + 3.089313816368428e-17 + ], + "x_dir": [ + -1.0, + 1.3153723711470598e-10, + -1.6540802198634257e-09 + ], + "y_dir": [ + -1.6593020853332313e-09, + -0.07932669684361024, + 0.996848672150333 + ], + "normal": [ + -9.000000000000026e-14, + 0.996848672150333, + 0.07932669684361024 + ], + "wires": [ + { + "edges": [ + { + "kind": "circle", + "start": [ + 1.7, + 3.9463258065123386e-11, + -4.962243907043456e-10 + ], + "end": [ + 1.7, + 3.9463263893954504e-11, + -4.962244639515977e-10 + ], + "parameter_range": [ + 0.0, + 6.283185307179586 + ], + "reversed": false, + "center": [ + 2.0, + 6.661338147750939e-16, + 0.0 + ], + "radius": 0.3, + "normal": [ + -8.536480491004258e-14, + 0.996848672150333, + 0.07932669684360946 + ], + "x_dir": [ + -1.0, + 1.3154197310436203e-10, + -1.6540813023478187e-09 + ] + } + ], + "closed": true + } + ] + }, + "path": { + "edges": [ + { + "kind": "bspline", + "start": [ + 2.0, + 6.661338147750939e-16, + 0.0 + ], + "end": [ + 2.0, + -5.047582789074024e-15, + 10.000000000000002 + ], + "parameter_range": [ + 0.0, + 63.62265131567328 + ], + "reversed": false, + "degree": 13, + "poles": [ + [ + 2.0, + 6.661338147750939e-16, + 0.0 + ], + [ + 1.9999999999999483, + 0.6041524333821656, + 0.04807692307685436 + ], + [ + 1.8022915771936825, + 1.208304870905466, + 0.09615384615415443 + ], + [ + 1.4068747452798505, + 1.7418755258527725, + 0.14423076922994169 + ], + [ + 0.8414668189386844, + 2.1342829054726824, + 0.1923076923092902 + ], + [ + 0.16150280081281543, + 2.3270383484976986, + 0.24038461538226746 + ], + [ + -0.555802317397056, + 2.285844591901501, + 0.28846153846423295 + ], + [ + -1.2233246240282272, + 2.009347799270346, + 0.336538461536015 + ], + [ + -1.759664321949602, + 1.5312648706945784, + 0.3846153846171492 + ], + [ + -2.104172809238839, + 0.9141590215986823, + 0.43269230769130473 + ], + [ + -2.226502668984004, + 0.23688132365397352, + 0.4807692307696662 + ], + [ + -2.128813163865841, + -0.4200120279538607, + 0.5288461538460247 + ], + [ + -1.8414138448882833, + -0.9870132798576515, + 0.5769230769230892 + ], + [ + -0.9870132798577862, + -1.841413844888405, + 0.6730769230769338 + ], + [ + -0.42001202795322584, + -2.1288131638652668, + 0.7211538461536989 + ], + [ + 0.2368813236521682, + -2.2265026689856753, + 0.7692307692313213 + ], + [ + 0.9141590216025747, + -2.1041728092354055, + 0.8173076923063703 + ], + [ + 1.531264870687806, + -1.7596643219548758, + 0.8653846153869104 + ], + [ + 2.009347799279881, + -1.223324624021997, + 0.9134615384585185 + ], + [ + 2.2858445918908323, + -0.5558023174028356, + 0.9615384615415711 + ], + [ + 2.327038348507003, + 0.1615028008170587, + 1.0096153846128404 + ], + [ + 2.134282905466487, + 0.8414668189362138, + 1.0576923076939477 + ], + [ + 1.7418755258558447, + 1.40687474528098, + 1.1057692307684408 + ], + [ + 1.2083048709043918, + 1.802291577193289, + 1.153846153846394 + ], + [ + 0.6041524333823806, + 2.0000000000000338, + 1.2019230769230707 + ], + [ + -0.60415243338235, + 1.9999999999999694, + 1.2980769230768512 + ], + [ + -1.2083048709047663, + 1.802291577193527, + 1.346153846154394 + ], + [ + -1.7418755258545406, + 1.406874745280456, + 1.3942307692290825 + ], + [ + -2.1342829054693033, + 0.8414668189370608, + 1.4423076923112175 + ], + [ + -2.3270383485027906, + 0.1615028008159628, + 1.490384615379138 + ], + [ + -2.2858445918954327, + -0.5558023174016837, + 1.5384615384681204 + ], + [ + -2.009347799276032, + -1.2233246240229605, + 1.5865384615321823 + ], + [ + -1.5312648706904137, + -1.7596643219542796, + 1.6346153846201954 + ], + [ + -0.9141590216010391, + -2.1041728092356133, + 1.6826923076893723 + ], + [ + -0.23688132365297554, + -2.2265026689856637, + 1.730769230770599 + ], + [ + 0.4200120279535802, + -2.1288131638652725, + 1.7788461538457223 + ], + [ + 0.9870132798576695, + -1.8414138448883566, + 1.826923076923126 + ], + [ + 1.8414138448884514, + -0.9870132798577959, + 1.9230769230769404 + ], + [ + 2.128813163864945, + -0.4200120279529417, + 1.9711538461535816 + ], + [ + 2.226502668986428, + 0.23688132365119724, + 2.019230769231603 + ], + [ + 2.1041728092342944, + 0.9141590216045443, + 2.067307692305985 + ], + [ + 1.759664321955971, + 1.531264870684877, + 2.1153846153872093 + ], + [ + 1.223324624021276, + 2.009347799283421, + 2.1634615384584075 + ], + [ + 0.5558023174030458, + 2.285844591887129, + 2.2115384615415885 + ], + [ + -0.16150280081684026, + 2.3270383485103614, + 2.2596153846127724 + ], + [ + -0.8414668189366271, + 2.134282905463938, + 2.3076923076941025 + ], + [ + -1.4068747452806216, + 1.741875525857392, + 2.3557692307682663 + ], + [ + -1.802291577193468, + 1.2083048709036788, + 2.4038461538465112 + ], + [ + -1.999999999999993, + 0.6041524333826138, + 2.4519230769230216 + ], + [ + -2.0000000000000036, + -0.60415243338269, + 2.548076923076934 + ], + [ + -1.8022915771934396, + -1.208304870902915, + 2.5961538461539533 + ], + [ + -1.406874745280619, + -1.7418755258598626, + 2.6442307692302807 + ], + [ + -0.8414668189367117, + -2.134282905458664, + 2.692307692309037 + ], + [ + -0.1615028008165532, + -2.327038348518791, + 2.740384615381839 + ], + [ + 0.5558023174023855, + -2.2858445918765837, + 2.7884615384658793 + ], + [ + 1.223324624022344, + -2.009347799293845, + 2.8365384615333173 + ], + [ + 1.7596643219547532, + -1.531264870676808, + 2.8846153846199845 + ], + [ + 2.1041728092353202, + -0.9141590216093117, + 2.932692307689301 + ], + [ + 2.22650266898584, + -0.23688132364910672, + 2.980769230770539 + ], + [ + 2.128813163865153, + 0.42001202795234166, + 3.028846153845933 + ], + [ + 1.841413844888438, + 0.987013279857846, + 3.0769230769229154 + ], + [ + 0.9870132798576133, + 1.8414138448884376, + 3.1730769230774123 + ], + [ + 0.42001202795398135, + 2.128813163864508, + 3.221153846150588 + ], + [ + -0.23688132365419814, + 2.226502668988156, + 3.2692307692407536 + ], + [ + -0.9141590215985614, + 2.1041728092302887, + 3.317307692286612 + ], + [ + -1.5312648706939194, + 1.7596643219626364, + 3.365384615418172 + ], + [ + -2.00934779927267, + 1.2233246240127316, + 3.413461538419854 + ], + [ + -2.2858445918974035, + 0.5558023174118611, + 3.461538461579471 + ], + [ + -2.327038348502379, + -0.16150280082438673, + 3.509615384583322 + ], + [ + -2.134282905468952, + -0.8414668189313265, + 3.557692307712066 + ], + [ + -1.7418755258549337, + -1.4068747452834651, + 3.605769230759894 + ], + [ + -1.2083048709045383, + -1.8022915771924415, + 3.6538461538492917 + ], + [ + -0.6041524333824554, + -2.0000000000001457, + 3.701923076922517 + ], + [ + 0.6041524333825566, + -1.9999999999999754, + 3.798076923077314 + ], + [ + 1.2083048709032667, + -1.8022915771931862, + 3.8461538461525504 + ], + [ + 1.7418755258591465, + -1.4068747452816484, + 3.894230769233875 + ], + [ + 2.1342829054596724, + -0.841466818934496, + 3.942307692302027 + ], + [ + 2.32703834851759, + -0.16150280082005888, + 3.990384615392585 + ], + [ + 2.285844591877996, + 0.555802317406608, + 4.038461538452697 + ], + [ + 2.0093477992920947, + 1.2233246240182585, + 4.0865384615462865 + ], + [ + 1.5312648706787897, + 1.7596643219578538, + 4.134615384609838 + ], + [ + 0.9141590216076623, + 2.1041728092334813, + 4.182692307695468 + ], + [ + 0.23688132365004666, + 2.226502668986602, + 4.230769230767802 + ], + [ + -0.4200120279526195, + 2.128813163865019, + 4.278846153846611 + ], + [ + -0.9870132798578423, + 1.8414138448883532, + 4.326923076923031 + ], + [ + -1.8414138448883082, + 0.9870132798579057, + 4.423076923076879 + ], + [ + -2.1288131638654924, + 0.42001202795204434, + 4.471153846154212 + ], + [ + -2.2265026689851264, + -0.23688132364829764, + 4.519230769229973 + ], + [ + -2.104172809236565, + -0.9141590216110625, + 4.567307692308481 + ], + [ + -1.7596643219528143, + -1.5312648706739498, + 4.615384615384955 + ], + [ + -1.223324624024944, + -2.0093477992974025, + 4.663461538458743 + ], + [ + -0.555802317399491, + -2.2858445918732224, + 4.711538461543929 + ], + [ + 0.16150280081409893, + -2.3270383485212665, + 4.759615384608758 + ], + [ + 0.8414668189382435, + -2.1342829054572143, + 4.807692307697982 + ], + [ + 1.4068747452799755, + -1.741875525860566, + 4.855769230765668 + ], + [ + 1.8022915771936252, + -1.2083048709025832, + 4.903846153847806 + ], + [ + 1.9999999999999802, + -0.6041524333828419, + 4.951923076922511 + ], + [ + 2.0000000000000084, + 0.6041524333829378, + 5.048076923077781 + ], + [ + 1.8022915771935002, + 1.2083048709016495, + 5.096153846149207 + ], + [ + 1.40687474528029, + 1.7418755258633165, + 5.14423076924378 + ], + [ + 0.8414668189379731, + 2.1342829054516783, + 5.1923076922821405 + ], + [ + 0.1615028008136067, + 2.3270383485300115, + 5.24038461542245 + ], + [ + -0.5558023173980627, + 2.2858445918620824, + 5.2884615384179465 + ], + [ + -1.2233246240265405, + 2.0093477993088764, + 5.336538461578303 + ], + [ + -1.759664321951844, + 1.5312648706645449, + 5.384615384586182 + ], + [ + -2.10417280923674, + 0.9141590216169742, + 5.432692307709485 + ], + [ + -2.226502668985374, + 0.23688132364566097, + 5.480769230761262 + ], + [ + -2.128813163865221, + -0.42001202795128517, + 5.528846153848939 + ], + [ + -1.841413844888457, + -0.9870132798580189, + 5.576923076922424 + ], + [ + -0.9870132798575849, + -1.8414138448882669, + 5.6730769230776925 + ], + [ + -0.420012027954111, + -2.128813163865314, + 5.721153846149946 + ], + [ + 0.2368813236545341, + -2.2265026689858023, + 5.7692307692421325 + ], + [ + 0.9141590215976688, + -2.1041728092354037, + 5.817307692284152 + ], + [ + 1.531264870696111, + -1.7596643219539576, + 5.86538461542164 + ], + [ + 2.009347799268774, + -1.2233246240241786, + 5.913461538416068 + ], + [ + 2.2858445919022303, + -0.5558023174003069, + 5.961538461582642 + ], + [ + 2.3270383484981876, + 0.1615028008155162, + 6.0096153845812825 + ], + [ + 2.134282905471544, + 0.8414668189366524, + 6.057692307713076 + ], + [ + 1.7418755258537841, + 1.4068747452810244, + 6.105769230759544 + ], + [ + 1.2083048709048787, + 1.8022915771932297, + 6.153846153849315 + ], + [ + 0.6041524333823935, + 2.000000000000041, + 6.201923076922612 + ], + [ + -0.6041524333825374, + 1.9999999999999893, + 6.298076923077063 + ], + [ + -1.2083048709034343, + 1.8022915771934118, + 6.346153846154186 + ], + [ + -1.741875525858368, + 1.4068747452807753, + 6.394230769229149 + ], + [ + -2.134282905461634, + 0.8414668189366404, + 6.4423076923116795 + ], + [ + -2.327038348514876, + 0.16150280081609175, + 6.4903846153772005 + ], + [ + -2.285844591879941, + -0.5558023174015779, + 6.538461538472675 + ], + [ + -2.0093477992921986, + -1.2233246240226923, + 6.586538461524955 + ], + [ + -1.5312648706769878, + -1.759664321955127, + 6.634615384628441 + ], + [ + -0.9141590216095852, + -2.104172809234644, + 6.682692307682479 + ], + [ + -0.23688132364902123, + -2.22650266898628, + 6.730769230774807 + ], + [ + 0.4200120279523284, + -2.1288131638650727, + 6.778846153843907 + ], + [ + 0.9870132798579115, + -1.8414138448883368, + 6.826923076923632 + ], + [ + 1.8414138448882231, + -0.9870132798579234, + 6.923076923076314 + ], + [ + 2.1288131638659307, + -0.42001202795207304, + 6.971153846156448 + ], + [ + 2.2265026689837657, + 0.23688132364868128, + 7.019230769224817 + ], + [ + 2.104172809239701, + 0.9141590216094687, + 7.067307692316733 + ], + [ + 1.7596643219474462, + 1.531264870677658, + 7.115384615374962 + ], + [ + 1.22332462403152, + 2.009347799291817, + 7.1634615384687494 + ], + [ + 0.5558023173941883, + 2.285844591878955, + 7.211538461535101 + ], + [ + -0.1615028008117135, + 2.327038348517077, + 7.259615384615659 + ], + [ + -0.8414668189383224, + 2.1342829054594192, + 7.307692307693514 + ], + [ + -1.4068747452805237, + 1.7418755258597582, + 7.355769230767805 + ], + [ + -1.8022915771932797, + 1.208304870902799, + 7.403846153847179 + ], + [ + -2.000000000000064, + 0.6041524333828056, + 7.4519230769225455 + ], + [ + -1.9999999999999298, + -0.6041524333828427, + 7.548076923077893 + ], + [ + -1.802291577193757, + -1.2083048709021935, + 7.5961538461480504 + ], + [ + -1.4068747452799983, + -1.741875525861654, + 7.644230769248086 + ], + [ + -0.8414668189377974, + -2.1342829054549712, + 7.692307692271547 + ], + [ + -0.16150280081486876, + -2.32703834852532, + 7.740384615441791 + ], + [ + 0.555802317400229, + -2.2858445918671535, + 7.788461538390869 + ], + [ + 1.2233246240243516, + -2.0093477993044764, + 7.836538461607568 + ], + [ + 1.7596643219533266, + -1.5312648706676915, + 7.884615384561717 + ], + [ + 2.104172809236037, + -0.9141590216151801, + 7.932692307725156 + ], + [ + 2.2265026689855025, + -0.23688132364645745, + 7.980769230753871 + ], + [ + 2.128813163865374, + 0.42001202795148923, + 8.028846153851099 + ], + [ + 1.8414138448882706, + 0.9870132798580143, + 8.076923076922437 + ], + [ + 0.987013279858011, + 1.8414138448882098, + 8.173076923076875 + ], + [ + 0.420012027951521, + 2.128813163865906, + 8.22115384615648 + ], + [ + -0.23688132364686182, + 2.226502668983463, + 8.26923076922096 + ], + [ + -0.9141590216137264, + 2.104172809241313, + 8.31730769233036 + ], + [ + -1.531264870670311, + 1.7596643219434511, + 8.365384615346466 + ], + [ + -2.009347799301379, + 1.2233246240379547, + 8.413461538510797 + ], + [ + -2.2858445918695356, + 0.5558023173866748, + 8.461538461488567 + ], + [ + -2.327038348524108, + -0.16150280080508977, + 8.5096153846554 + ], + [ + -2.134282905455498, + -0.8414668189427993, + 8.557692307667162 + ], + [ + -1.7418755258613183, + -1.4068747452782566, + 8.605769230781075 + ], + [ + -1.20830487090241, + -1.8022915771940946, + 8.653846153842522 + ], + [ + -0.604152433382828, + -1.999999999999907, + 8.701923076923327 + ], + [ + 0.6041524333828305, + -2.0000000000000564, + 8.798076923077526 + ], + [ + 1.208304870902372, + -1.8022915771933377, + 8.846153846148837 + ], + [ + 1.7418755258609533, + -1.4068747452807895, + 8.894230769245528 + ], + [ + 2.134282905456969, + -0.8414668189369883, + 8.942307692278401 + ], + [ + 2.3270383485210635, + -0.16150280081474325, + 8.990384615428868 + ], + [ + 2.285844591873969, + 0.5558023173983309, + 9.038461538408193 + ], + [ + 2.0093477992963296, + 1.2233246240276605, + 9.086538461590958 + ], + [ + 1.5312648706749636, + 1.7596643219501886, + 9.134615384572934 + ], + [ + 0.91415902161026, + 2.1041728092378444, + 9.182692307720423 + ], + [ + 0.2368813236489844, + 2.2265026689849927, + 9.230769230754154 + ], + [ + -0.42001202795247133, + 2.1288131638652503, + 9.278846153852554 + ], + [ + -0.9870132798577462, + 1.8414138448885005, + 9.326923076921004 + ], + [ + -1.8414138448885735, + 0.9870132798574845, + 9.423076923079982 + ], + [ + -2.1288131638639047, + 0.42001202795476394, + 9.471153846136946 + ], + [ + -2.22650266898944, + -0.2368813236564224, + 9.519230769279703 + ], + [ + -2.104172809228791, + -0.9141590215942135, + 9.567307692207855 + ], + [ + -1.7596643219632289, + -1.5312648707004843, + 9.615384615539929 + ], + [ + -1.22332462401359, + -2.0093477992648854, + 9.663461538271 + ], + [ + -0.5558023174105057, + -2.2858445919045973, + 9.711538461725837 + ], + [ + 0.16150280082377924, + -2.3270383484972044, + 9.759615384466972 + ], + [ + 0.8414668189311059, + -2.1342829054719186, + 9.80769230778639 + ], + [ + 1.4068747452839687, + -1.741875525853499, + 9.85576923072261 + ], + [ + 1.8022915771920602, + -1.2083048709051603, + 9.903846153863118 + ], + [ + 2.0000000000003317, + -0.6041524333822196, + 9.951923076919346 + ], + [ + 2.0, + -5.047582789074024e-15, + 10.000000000000002 + ] + ], + "weights": [ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0 + ], + "knots": [ + 0.0, + 3.97641570722958, + 7.95283141445916, + 11.92924712168874, + 15.90566282891832, + 19.8820785361479, + 23.85849424337748, + 27.83490995060706, + 31.81132565783664, + 35.787741365066225, + 39.7641570722958, + 43.74057277952538, + 47.71698848675496, + 51.693404193984534, + 55.66981990121412, + 59.6462356084437, + 63.62265131567328 + ], + "multiplicities": [ + 14, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 14 + ], + "periodic": false + } + ], + "closed": false + }, + "inner_wires": [] + } + ], + "result_refs": [ + "s1" + ], + "b3d_volume": 35.642805167823504, + "b3d_volume_gk": 35.642805167823504, + "b3d_default_volume": 35.642681367230885, + "b3d_bbox": [ + -2.300012799317609, + -2.3000127993174146, + -0.2990547016451006, + 2.3000127993175012, + 2.3000127993174946, + 10.299054701644959 + ], + "solid_count": 1, + "b3d_status": "ok", + "unsupported": [], + "fixture_provenance": { + "source_stem": "50_spring", + "build123d_version": "0.13.0", + "source_kernel": "8.0.1.1", + "reference_volume_method": "Gauss-Kronrod, eps=1e-9, use_span=True" + } +} diff --git a/test/test_affine_geometry_isolation.py b/test/test_affine_geometry_isolation.py new file mode 100644 index 00000000..2daea3ef --- /dev/null +++ b/test/test_affine_geometry_isolation.py @@ -0,0 +1,25 @@ +"""Complex shared fillet geometry must survive nonuniform scale without a crash.""" +import json +from pathlib import Path +import sys + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tools/research/build123dftc")) +from b3ftc.replay import replay_trace_to_ftc +from b3ftc.validation import _worker + + +def test_nonuniform_scale_after_spherical_cut_and_fillet(tmp_path): + trace = json.loads((ROOT / "test/build123d_traces/affine_trimmed_sphere.trace.json").read_text()) + source, meta = replay_trace_to_ftc(trace, stem="affine-shared-geometry") + assert meta["status"] == "ok" + path = tmp_path / "affine.ftc.py" + path.write_text(source) + # A native kernel regression can segfault. Keep the test runner alive and + # report it as a failing feature, exactly like the external acceptance tool. + metrics = _worker(path, tmp_path / "work", 30, None, sys.executable, None) + assert metrics["status"] == "ok", metrics + assert metrics["is_valid"] is True + assert metrics["volume"] == pytest.approx(trace["b3d_volume"], rel=1e-6) diff --git a/test/test_build123d_cli.py b/test/test_build123d_cli.py new file mode 100644 index 00000000..7271c482 --- /dev/null +++ b/test/test_build123d_cli.py @@ -0,0 +1,88 @@ +"""The pure stage-2 boundary and batch input discovery contracts.""" +import importlib.util +import json +import sys +from pathlib import Path + +import pytest + +TOOLS = Path(__file__).resolve().parents[1] / "tools/research/build123dftc" +sys.path.insert(0, str(TOOLS)) + + +def _script(name): + spec = importlib.util.spec_from_file_location(name, TOOLS / f"{name}.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def test_translate_writes_reviewable_source_and_sidecars(tmp_path): + payload = {"schema_version": "1.0", "stem": "box", "b3d_status": "ok", + "unsupported": [], "steps": [{"id": "base", "op": "box", "inputs": [], + "parameters": {"length": 10, "width": 8, "height": 4}}], + "result_refs": ["base"], "b3d_volume": 320, + "b3d_bbox": [0, 0, 0, 10, 8, 4], "solid_count": 1} + trace = tmp_path / "box.trace.json" + trace.write_text(json.dumps(payload)) + stem, source, meta = _script("build123d_to_ftc").translate_trace_file(trace, tmp_path / "out") + assert stem == "box" + assert meta["status"] == "ok" + assert "feature:" in source and "make_box_rsolid" in source + assert (tmp_path / "out/box.ftc.py").exists() + assert (tmp_path / "out/box.meta.json").exists() + assert (tmp_path / "out/box.sketches.json").exists() + + +@pytest.mark.parametrize("stem", ["../escape", "/absolute", "..", "nested/file"]) +def test_trace_cannot_write_outside_output_directory(tmp_path, stem): + trace = tmp_path / "bad.trace.json" + trace.write_text(json.dumps({"schema_version": "1.0", "stem": stem, "steps": []})) + with pytest.raises(ValueError): + _script("build123d_to_ftc").translate_trace_file(trace, tmp_path / "out") + assert not (tmp_path / "out").exists() + + +def test_future_schema_is_not_silently_reinterpreted(tmp_path): + trace = tmp_path / "bad.trace.json" + trace.write_text(json.dumps({"schema_version": "999", "steps": []})) + with pytest.raises(ValueError, match="schema"): + _script("build123d_to_ftc").translate_trace_file(trace, tmp_path / "out") + + +def test_manifest_resolves_only_declared_models(tmp_path): + models = tmp_path / "models" + models.mkdir() + for name in ("one.py", "two.py", "extra.py"): + (models / name).write_text("") + manifest = tmp_path / "manifest.json" + manifest.write_text(json.dumps({"examples": [{"file": "models/one.py"}, {"file": "models/two.py"}]})) + actual = _script("build123d_trace").discover_inputs(manifest=manifest) + assert [p.name for p in actual] == ["one.py", "two.py"] + + +@pytest.mark.parametrize("timeout", ["nan", "inf", "0", "-1"]) +def test_capture_rejects_unbounded_or_invalid_timeouts(timeout): + with pytest.raises(SystemExit) as error: + _script("build123d_trace").main(["--input", "unused.py", "--timeout", timeout]) + assert error.value.code == 2 + + +def test_validator_cli_reports_failure_with_nonzero_exit(tmp_path, monkeypatch): + module = _script("build123d_validate") + report = {"rows": [{"stem": "broken", "quality": "rejected", "build": "build_error", + "reasons": ["build_failed"]}], + "counts": {"accepted": 0, "partial": 0, "rejected": 1}} + monkeypatch.setattr(module, "validate_directory", lambda *a, **kw: report) + output = tmp_path / "report.json" + assert module.main(["--ftc-dir", str(tmp_path), "--traces-dir", str(tmp_path), + "--report", str(output)]) == 1 + assert json.loads(output.read_text())["counts"]["rejected"] == 1 + + +@pytest.mark.parametrize("timeout", ["nan", "inf", "-1", "0"]) +def test_validator_cli_rejects_nonfinite_or_nonpositive_timeout(tmp_path, timeout): + with pytest.raises(SystemExit) as exc: + _script("build123d_validate").main(["--ftc-dir", str(tmp_path), "--traces-dir", str(tmp_path), + "--timeout", timeout]) + assert exc.value.code == 2 diff --git a/test/test_build123d_review_regressions.py b/test/test_build123d_review_regressions.py new file mode 100644 index 00000000..cfe07ca2 --- /dev/null +++ b/test/test_build123d_review_regressions.py @@ -0,0 +1,90 @@ +"""Review reproductions cross the two isolated kernel environments end to end.""" +import json +from pathlib import Path +import subprocess +import sys + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tools/research/build123dftc")) +from b3ftc.replay import replay_trace_to_ftc +from b3ftc.validation import compare_metrics +from b3ftc._validate_worker import run + + +def capture(source): + python = ROOT.parent / ".venv/bin/python" + if not python.is_file(): + pytest.skip("isolated build123d environment is unavailable") + worker = "import json,sys; sys.path.insert(0,'tools/research/build123dftc'); from b3ftc.tracer import trace_source; print(json.dumps(trace_source(sys.stdin.read())))" + process = subprocess.run([str(python), "-c", worker], input="from build123d import *\n" + source, + text=True, capture_output=True, cwd=ROOT, timeout=30, check=True) + trace = json.loads(process.stdout) + assert trace["b3d_status"] == "ok", trace + return trace + + +@pytest.mark.parametrize("source", [ + "result=Solid.make_torus(5,1,major_angle=120)", + "a=Solid.make_box(10,2,2)\nb=Solid.make_box(2,4,4).moved(Location((4,-1,-1)))\nresult=a.cut(b)", + "a=Solid.make_box(10,2,2)\nb=Solid.make_box(2,4,4).moved(Location((4,-1,-1)))\nresult=a.cut(b).solids()[1].moved(Location((0,5,0)))", + "a=Solid.make_box(10,2,2)\nb=Solid.make_box(2,4,4)\nc=Solid.make_box(2,4,4).moved(Location((8,0,0)))\nresult=a.intersect(Compound([b,c]))", + "a=Solid.make_box(2,2,2)\nb=Solid.make_box(2,2,2).moved(Location((4,0,0)))\nc=Compound([a,b])\nresult=c.fillet(.2, c.edges().filter_by(Axis.Z))", + "a=Solid.make_box(2,2,2)\nb=Solid.make_box(2,2,2).moved(Location((4,0,0)))\nc=Compound([a,b])\nresult=c.fillet(.2, a.edges().filter_by(Axis.Z))", + "a=Solid.make_box(2,2,2)\nresult=a.split(Plane.XY.offset(10), keep=Keep.BOTH)", +]) +def test_review_geometry_reconciles_with_actual_return(tmp_path, source): + trace = capture(source) + generated, meta = replay_trace_to_ftc(trace, stem="review") + assert meta["status"] == "ok", meta + ftc = tmp_path / "review.ftc.py" + ftc.write_text(generated) + stage = tmp_path / "staged" + stage.mkdir() + metrics = run(ftc, stage) + comparison = compare_metrics(trace, metrics, meta) + assert comparison["quality"] == "accepted", comparison + + +@pytest.mark.parametrize("angles", ["start_angle=-30", "end_angle=80", "start_angle=-30,end_angle=80,major_angle=140"]) +def test_partial_torus_tube_is_explicitly_unsupported(angles): + trace = capture(f"result=Solid.make_torus(5,1,{angles})") + generated, meta = replay_trace_to_ftc(trace) + assert meta["status"] == "partial" + assert any("partial torus tube" in str(note) for note in meta["unsupported"]) + assert "feature tree produced no solid" in generated + + +def test_solid_ordering_uses_bounds_when_centroids_differ_between_kernels(tmp_path): + trace = capture("a=Solid.make_box(2,2,2)\nb=a.moved(Location((4,0,0)))\nresult=Compound([a,b])") + for step in trace["steps"]: + for component in step.get("result_components", []): + component["center"] = [1234, 5678, 9000] + generated, meta = replay_trace_to_ftc(trace, stem="bounds") + assert meta["status"] == "ok" + ftc = tmp_path / "bounds.ftc.py" + ftc.write_text(generated) + stage = tmp_path / "stage" + stage.mkdir() + assert compare_metrics(trace, run(ftc, stage), meta)["quality"] == "accepted" + + +@pytest.mark.parametrize("source", [ + "b=Box(1,2,3)+Cylinder(.75,2.5)\nwith BuildPart() as bp:\n insert(b)\n Cylinder(.4,6,mode=Mode.SUBTRACT)\nresult=bp.part", + "a=Box(4,4,4)\nb=Box(4,4,4).moved(Location((2,0,0)))\nresult=Part([a]) & b", + "section=RegularPolygon(1,6).face()\nresult=Solid.extrude_linear_with_rotation(section,(0,0),(0,0,5),72)", + "face=Face(Wire.make_circle(2),[Wire.make_circle(1)])\nresult=Solid.sweep(face,Wire([Edge.make_three_point_arc((0,0,0),(3,0,2),(5,0,5))]))", + "v=[(1,1,1),(1,-1,-1),(-1,1,-1),(-1,-1,1)]\nf=[[0,1,2],[0,3,1],[0,2,3],[1,3,2]]\nresult=Solid(Shell([Face(Wire.make_polygon([v[i] for i in face])) for face in f])).clean()", + "result=ConvexPolyhedron([(0,0,0),(1,0,0),(0,1,0),(0,0,1)])", +]) +def test_additional_fix_candidates_reconcile(tmp_path, source): + trace = capture(source) + generated, meta = replay_trace_to_ftc(trace, stem="candidate") + assert meta["status"] == "ok", meta + ftc = tmp_path / "candidate.ftc.py" + ftc.write_text(generated) + stage = tmp_path / "stage" + stage.mkdir() + comparison = compare_metrics(trace, run(ftc, stage), meta) + assert comparison["quality"] == "accepted", comparison diff --git a/test/test_build123d_trace.py b/test/test_build123d_trace.py new file mode 100644 index 00000000..a1e68f0a --- /dev/null +++ b/test/test_build123d_trace.py @@ -0,0 +1,260 @@ +"""Feature tracing regressions, independent of the SimpleCAD runtime.""" +from pathlib import Path +import copy +import json +import sys + +import pytest + +b = pytest.importorskip("build123d") +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tools/research/build123dftc")) +from b3ftc.geometry import edge as transcribe_edge +from b3ftc.geometry import fingerprint +from b3ftc.tracer import trace_source + + +def checked(source): + trace = trace_source(source) + assert trace["b3d_status"] == "ok", trace["error"] + assert trace["unsupported"] == [] + known = set() + for step in trace["steps"]: + assert set(step["inputs"]) <= known + known.add(step["id"]) + assert set(trace["result_refs"]) <= known + json.dumps(trace, allow_nan=False) + return trace + + +def test_builder_profile_is_actual_placed_face_with_hole(): + trace = checked("""from build123d import * +with BuildPart() as bp: + with BuildSketch(Plane.XY.offset(7)): + Rectangle(10, 8) + Circle(2, mode=Mode.SUBTRACT) + extrude(amount=3) +result = bp.part +""") + feature = next(s for s in trace["steps"] if s["op"] == "extrude") + assert len(feature["profile"]["wires"]) == 2 + assert feature["profile"]["origin"][2] == pytest.approx(7) + assert trace["b3d_bbox"][2::3] == pytest.approx([7, 10]) + assert trace["b3d_volume"] == pytest.approx((80 - 4 * 3.141592653589793) * 3) + + +def test_algebra_has_boolean_dependencies_and_transform_snapshots(): + trace = checked("""from build123d import * +base = Box(10, 10, 10) +base.move(Location((3, 0, 0))) +result = base - Pos(3, 0, 0) * Cylinder(2, 20) +""") + assert trace["steps"][-1]["op"] == "cut" + assert len(trace["steps"][-1]["inputs"]) == 2 + transform = [s for s in trace["steps"] if s["op"] == "transform"] + assert transform[0]["result"]["bbox"][0] == -5 + assert transform[1]["result"]["bbox"][0] == -2 + assert trace["b3d_volume"] == pytest.approx(1000 - 40 * 3.141592653589793) + + +def test_nested_builder_publication_is_captured_once(): + trace = checked("""from build123d import * +with BuildPart(Plane.XY.offset(10)) as bp: + with Locations((4, 0, 0)): + Box(2, 2, 2) +result = bp.part +""") + assert len([s for s in trace["steps"] if s["op"] == "box"]) == 1 + assert trace["b3d_bbox"] == pytest.approx([3, -1, 9, 5, 1, 11]) + + +def test_deepcopy_mirror_preserves_feature_reference(): + trace = checked("""from build123d import * +import copy +original = Solid.make_box(2, 3, 4) +result = copy.deepcopy(original).mirror(Plane.YZ) +""") + assert [s["op"] for s in trace["steps"]] == ["box", "transform"] + assert trace["b3d_bbox"] == pytest.approx([-2, 0, 0, 0, 3, 4]) + + +def test_multiple_solid_components_and_union_groups(): + trace = checked("""from build123d import * +a = Solid.make_box(1, 1, 1) +b = Solid.make_box(1, 1, 1).moved(Location((3, 0, 0))) +group = a.fuse(b).moved(Location((0, 0, 2))) +result = group.solids()[0].moved(Location((0, 2, 0))) +""") + union = next(s for s in trace["steps"] if s["op"] == "union") + assert union["result"]["solid_count"] == 2 + assert len(union["result_groups"]) == 2 + assert all(group for group in union["result_groups"]) + assert any(s["op"] == "component" for s in trace["steps"]) + assert trace["b3d_volume"] == pytest.approx(1) + + +def test_selection_fingerprints_for_fillet_and_shell(): + trace = checked("""from build123d import * +with BuildPart() as bp: + Box(10, 10, 10) + fillet(bp.edges().filter_by(Axis.Z), 1) + offset(amount=-.5, openings=bp.faces().sort_by(Axis.Z)[-1]) +result=bp.part +""") + fillet = next(s for s in trace["steps"] if s["op"] == "fillet") + shell = next(s for s in trace["steps"] if s["op"] == "offset") + assert len(fillet["selection"]) == 4 + assert shell["selection"][0]["kind"] == "face" + assert "normal" in shell["selection"][0] + + +def test_trimmed_spline_retains_exact_control_points(): + original = b.Edge.make_spline([(0, 0), (1, 2), (3, 1), (4, 0)]) + trimmed = original.trim(.2, .8) + encoded = transcribe_edge(trimmed) + assert encoded["kind"] == "bspline" + assert encoded["start"] == pytest.approx(tuple(trimmed.position_at(0))) + assert encoded["end"] == pytest.approx(tuple(trimmed.position_at(1))) + assert encoded["poles"][0] == pytest.approx(encoded["end"] if encoded["reversed"] else encoded["start"]) + + +def test_absolute_location_assignment_and_exact_conic_trim(): + trace = checked("""from build123d import * +result = Solid.make_box(2,3,4).moved(Location((2,0,0))) +result.location = Location((5,0,0)) +""") + assert trace["b3d_bbox"][0] == pytest.approx(5) + assert trace["steps"][-1]["parameters"]["matrix"][0][3] == pytest.approx(3) + conic = b.Edge.make_ellipse(3, 2, start_angle=10, end_angle=150) + data = transcribe_edge(conic) + assert data["kind"] == "bspline" + assert data["degree"] == 2 + assert any(weight != 1 for weight in data["weights"]) + + +def test_curved_selection_center_is_mass_center_and_no_arbitrary_surface_normal(): + arc = b.Edge.make_three_point_arc((1, 0), (0, 1), (-1, 0)) + data = fingerprint(arc) + assert data["center"] == pytest.approx(tuple(arc.center(b.CenterOf.MASS))) + assert data["center"] != pytest.approx(tuple(arc.center())) + sphere = b.Solid.make_sphere(2) + curved = fingerprint(sphere.faces()[0]) + assert "normal" not in curved + + +def test_scaling_resolves_actual_default_location_center(): + trace = checked("""from build123d import * +placed = Solid.make_box(2,3,4).moved(Location((10,0,0))) +result = placed.scale(2) +""") + assert trace["steps"][-1]["parameters"]["about"] == pytest.approx([10, 0, 0]) + assert trace["b3d_bbox"] == pytest.approx([10, 0, 0, 14, 6, 8]) + + +def test_factory_parameters_partial_angles_and_generator_inputs_are_preserved(): + trace = checked("""from build123d import * +a = Solid.make_cylinder(2,3,angle=120) +b = Solid.make_cone(3,1,4,angle=180).moved(Location((10,0,0))) +c = Solid.make_torus(5,1,start_angle=-30,end_angle=80,major_angle=140).moved(Location((20,0,0))) +result = a.fuse(b,c) +""") + assert next(s for s in trace["steps"] if s["op"] == "cylinder")["parameters"]["angle"] == 120 + torus = next(s for s in trace["steps"] if s["op"] == "torus") + assert torus["parameters"]["major_angle"] == 140 + trace = checked("""from build123d import * +wires = (Wire.make_circle(r, plane=Plane.XY.offset(z)) for r,z in [(2,0),(3,5)]) +result = Solid.make_loft(wires) +""") + assert len(trace["steps"][-1]["profiles"]) == 2 + + +def test_draft_is_transcribed_and_nonplanar_thicken_reports_surface_boundary(): + trace = checked("""from build123d import * +body = Solid.make_box(5,5,5) +side = body.faces().filter_by(Plane.YZ)[-1] +result = body.draft([side], Plane.XY, 5) +""") + draft = trace["steps"][-1] + assert draft["op"] == "draft" + assert len(draft["selection"]) == 1 + assert draft["parameters"]["neutral_plane"]["normal"] == [0, 0, 1] + trace = trace_source("""from build123d import * +face = Solid.make_sphere(2).faces()[0] +result = Solid.thicken(face, .2) +""") + assert trace["unsupported"] + assert any(s["op"] == "thicken" and "geometry_error" in s for s in trace["steps"]) + + +def test_unknown_kernel_solid_is_reported_and_errors_restore_patches(): + original = b.Solid.make_box.__func__ + owned_attributes = set(b.Solid.__dict__) + trace = trace_source("""from build123d import Solid +from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox +result = Solid(BRepPrimAPI_MakeBox(2, 3, 4).Solid()) +""") + assert trace["unsupported"] + assert trace["steps"][-1]["op"] == "unsupported" + assert b.Solid.make_box.__func__ is original + trace = trace_source("from build123d import *\nresult=Box(1,2,3)\nraise RuntimeError('expected')") + assert trace["b3d_status"] == "error" + assert "expected" in trace["error"] + assert b.Solid.make_box.__func__ is original + assert set(b.Solid.__dict__) == owned_attributes + + +def test_rational_circle_volume_uses_span_aware_adaptive_integration(): + trace = checked("""from build123d import * +from math import sqrt +points = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1),(1,0)] +weights = [1,sqrt(.5),1,sqrt(.5),1,sqrt(.5),1,sqrt(.5),1] +curve = Edge.make_bspline(points,[0,0,0,1,1,2,2,3,3,4,4,4],2,weights) +result = Solid.extrude(Face(Wire([curve])), (0,0,1)) +""") + assert trace["b3d_volume"] == pytest.approx(3.141592653589793, rel=1e-9) + assert trace["b3d_area"] == pytest.approx(4 * 3.141592653589793, rel=1e-9) + assert "b3d_default_volume" in trace + assert trace["steps"][-1]["profile"]["wires"][0]["edges"][0]["kind"] == "bspline" + + +def test_multiple_intersection_results_reference_individual_components(): + trace = checked("""from build123d import * +base = Solid.make_box(10,2,2) +left = Solid.make_box(2,4,4) +right = Solid.make_box(2,4,4).moved(Location((8,0,0))) +intersection = base.intersect(left.fuse(right)) +result = intersection[0].moved(Location((0,10,0))) +""") + assert any(s["op"] == "component" for s in trace["steps"]) + assert trace["solid_count"] == 1 + assert trace["b3d_volume"] == pytest.approx(8) + + +@pytest.mark.parametrize("result", ["a-a", "[]", "()", "None", "Compound([])"]) +def test_explicit_empty_result_never_promotes_old_solid(result): + trace = trace_source(f"from build123d import *\na=Box(2,2,2)\nresult={result}") + assert trace["b3d_status"] == "error" + assert trace["result_refs"] == [] + assert trace["solid_count"] == 0 + + +@pytest.mark.parametrize("z", [-10, 10]) +def test_both_split_with_empty_side_is_serializable(z): + trace = checked(f"""from build123d import * +a = Solid.make_box(2,2,2) +result = a.split(Plane.XY.offset({z}), keep=Keep.BOTH) +""") + assert trace["solid_count"] == 1 + assert trace["b3d_valid"] + assert trace["b3d_volume"] == pytest.approx(8) + + +@pytest.mark.parametrize("op", ["revolve", "sweep"]) +def test_face_section_ignores_explicit_inner_wires(op): + call = ("Solid.revolve(section, 360, Axis((0,0,0),(0,1,0)), inner_wires=[hole])" + if op == "revolve" else "Solid.sweep(section, Wire.make_polygon([(3,0,0),(3,0,5)]), inner_wires=[hole])") + trace = checked(f"""from build123d import * +section = Face(Wire.make_circle(1, plane=Plane((3,0,0)))) +hole = Wire.make_circle(.2, plane=Plane((3,0,0))) +result = {call} +""") + assert not trace["steps"][-1].get("inner_wires") diff --git a/test/test_build123d_translation_output.py b/test/test_build123d_translation_output.py new file mode 100644 index 00000000..701996e3 --- /dev/null +++ b/test/test_build123d_translation_output.py @@ -0,0 +1,285 @@ +"""Format and executable geometry tests for build123d FTC translation. + +Fixtures model the trace protocol without depending on build123d itself. +""" +from __future__ import annotations +import importlib.util +import math +import re +import sys +import tempfile +import unittest +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tools/research/build123dftc')) +from b3ftc.replay import replay_trace_to_ftc + + +def rectangle(x=10, y=6, z=0): + points = [(0, 0, z), (x, 0, z), (x, y, z), (0, y, z)] + return {'origin': (0, 0, z), 'u': (1, 0, 0), 'v': (0, 1, 0), + 'normal': (0, 0, 1), 'wires': [{'edges': [ + {'kind': 'line', 'start': a, 'end': b} + for a, b in zip(points, points[1:] + points[:1])]}]} + + +def circle(radius, z=0): + return {'origin': (0, 0, z), 'u': (1, 0, 0), 'v': (0, 1, 0), + 'normal': (0, 0, 1), 'wires': [{'edges': [ + {'kind': 'circle', 'center': (0, 0, z), 'radius': radius, + 'normal': (0, 0, 1), 'x_dir': (1, 0, 0)}]}]} + + +def trace(*steps): + return {'schema_version': '1.0', 'steps': list(steps), + 'result_refs': [steps[-1]['id']], 'unsupported': []} + + +class FormatTests(unittest.TestCase): + def test_vertex_loft_sections_use_keyword_arguments(self): + source, meta = replay_trace_to_ftc(trace({'id': 's1', 'op': 'loft', + 'profiles': [circle(2), {'kind': 'vertex', 'point': (0, 0, 5)}], + 'parameters': {'ruled': True}}), stem='pointed') + self.assertEqual(meta['status'], 'ok', meta) + self.assertIn('scad.make_point_rvertex(x=0, y=0, z=5)', source) + + def test_real_recorded_fixtures_need_no_build123d_dependency(self): + for path in sorted((ROOT / 'test/build123d_traces').glob('*.trace.json')): + with self.subTest(fixture=path.name): + import json + source, meta = replay_trace_to_ftc(json.loads(path.read_text()), stem=path.stem) + self.assertEqual(meta['status'], 'ok', meta['unsupported']) + compile(source, str(path), 'exec') + self.assertNotIn('import build123d', source) + self.assertNotIn('load_brep', source) + def test_sketch_extrusion_and_explicit_module_contract(self): + source, meta = replay_trace_to_ftc(trace({'id': 's1', 'op': 'extrude', + 'profile': rectangle(), 'parameters': {'direction': (0, 0, 1), 'distance': 4}}), stem='plate') + self.assertEqual(meta['status'], 'ok', meta) + self.assertIn('scad.make_sketch_rsketch(', source) + self.assertIn('scad.make_face_from_sketch_rface(', source) + self.assertIn('scad.extrude_rsolid(', source) + self.assertIn("project_root=Path(__file__).parent", source) + self.assertIn('BODIES = list(bodies)', source) + self.assertRegex(source, r'feature: extrude \(build, profile=geometry\)') + for text in ('import build123d', 'import OCP', 'load_brep', '.get_edges()', '.get_faces()'): + self.assertNotIn(text, source) + compile(source, '', 'exec') + + def test_unknown_feature_blocks_dependents(self): + source, meta = replay_trace_to_ftc(trace({'id': 's1', 'op': 'unknown'}, + {'id': 's2', 'op': 'translate', 'inputs': ['s1'], 'parameters': {'vector': (1, 0, 0)}}), stem='unknown') + self.assertEqual(meta['status'], 'partial') + self.assertTrue(any('unknown' in str(x) for x in meta['unsupported'])) + self.assertIn('feature tree produced no solid', source) + + def test_modifiers_use_individual_fingerprints(self): + payload = trace({'id': 's1', 'op': 'box', 'parameters': {'length': 10, 'width': 10, 'height': 10}}, + {'id': 's2', 'op': 'fillet', 'inputs': ['s1'], 'parameters': {'radius': 1}, + 'selection': [{'kind': 'edge', 'geom_type': 'LINE', 'center': [0, 0, 5], 'length': 10, 'area': 0}]}) + source, meta = replay_trace_to_ftc(payload, stem='filleted') + self.assertEqual(meta['status'], 'ok', meta) + self.assertIn('ql.edges()', source) + self.assertIn('.take(1).exactly(1)', source) + self.assertIn("ql.prop('geom.length'", source) + self.assertIn('scad.fillet_rsolid(', source) + self.assertNotIn('geom.area', source) + + def test_no_final_snapshot_fallback(self): + source, meta = replay_trace_to_ftc({'steps': [], 'final_brep': 'ignored'}, stem='empty') + self.assertEqual(meta['status'], 'partial') + self.assertNotIn('ignored', source) + self.assertNotIn('load_brep', source) + + def test_explicit_empty_results_do_not_promote_unused_tool(self): + payload = trace({'id': 's1', 'op': 'box', 'parameters': {'length': 1, 'width': 2, 'height': 3}}) + payload['result_refs'] = [] + source, meta = replay_trace_to_ftc(payload) + self.assertEqual(meta['status'], 'partial') + self.assertIn('feature tree produced no solid', source) + + def test_draft_uses_face_predicate_and_neutral_plane(self): + payload = trace({'id': 's1', 'op': 'box', 'parameters': {'length': 2, 'width': 2, 'height': 3}}, + {'id': 's2', 'op': 'draft', 'inputs': ['s1'], 'parameters': {'angle': 5, + 'neutral_plane': {'origin': (0, 0, 0), 'normal': (0, 0, 1)}}, + 'selection': [{'kind': 'face', 'geom_type': 'PLANE', 'center': (2, 1, 1.5), 'area': 6, 'length': 0}]}) + source, meta = replay_trace_to_ftc(payload) + self.assertEqual(meta['status'], 'ok', meta) + self.assertIn('scad.draft_rsolid(', source) + self.assertIn('faces_to_draft=ql.faces()', source) + self.assertNotIn('geom.length', source) + compile(source, '', 'exec') + + +class GeometryTests(unittest.TestCase): + def test_many_holes_use_small_sketches_and_preserve_all_loops(self): + profile = rectangle(500, 600) + for i in range(25): + for j in range(25): + x, y = 5 + 10 * i, 5 + 10 * j + points = [(x, y, 0), (x + 1, y, 0), (x + 1, y + 1, 0), (x, y + 1, 0)] + profile['wires'].append({'edges': [{'kind': 'line', 'start': a, 'end': b} + for a, b in zip(points, points[1:] + points[:1])]}) + payload = trace({'id': 's1', 'op': 'extrude', 'profile': profile, + 'parameters': {'direction': (0, 0, 1), 'distance': 1}}) + source, _ = replay_trace_to_ftc(payload) + self.assertIn('scad.make_face_from_wires_rface(', source) + self.build(payload, 500 * 600 - 625) + + def test_real_recorded_fixtures_reconcile(self): + import json + for path in sorted((ROOT / 'test/build123d_traces').glob('*.trace.json')): + with self.subTest(fixture=path.name): + payload = json.loads(path.read_text()) + self.build(payload, payload['b3d_volume']) + def build(self, payload, expected, *, constraints_mode=False): + source, meta = replay_trace_to_ftc(payload, stem='geometry', constraints_mode=constraints_mode) + self.assertEqual(meta['status'], 'ok', meta) + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / 'model.ftc.py' + path.write_text(source) + spec = importlib.util.spec_from_file_location('ftc_geometry_' + path.parent.name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.build() + self.assertEqual(len(module.BODIES), payload.get('solid_count', 1)) + from OCP.BRepCheck import BRepCheck_Analyzer + self.assertTrue(all(BRepCheck_Analyzer(body.wrapped).IsValid() for body in module.BODIES)) + from OCP.BRepGProp import BRepGProp + from OCP.GProp import GProp_GProps + def accurate_volume(body): + props = GProp_GProps() + BRepGProp.VolumePropertiesGK_s(body.wrapped, props, 1e-9, True, True) + return float(props.Mass()) + volume = sum(accurate_volume(body) for body in module.BODIES) + self.assertAlmostEqual(volume, expected, delta=max(abs(expected), 1) * 1e-6) + + def test_extruded_rectangle(self): + self.build(trace({'id': 's1', 'op': 'extrude', 'profile': rectangle(), + 'parameters': {'direction': (0, 0, 1), 'distance': 4}}), 240) + + def test_recovered_constraints_preserve_rectangle_geometry(self): + payload = trace({'id': 's1', 'op': 'extrude', 'profile': rectangle(), + 'parameters': {'direction': (0, 0, 1), 'distance': 4}}) + self.build(payload, 240, constraints_mode=True) + source, meta = replay_trace_to_ftc(payload, constraints_mode=True) + self.assertTrue(meta['sketches']) + self.assertEqual(meta['constraint_recovery'][0]['status'], 'riveted') + self.assertIn('scad.constrain_', source) + + def test_face_with_circle_hole(self): + profile = circle(5) + profile['wires'].extend(circle(2)['wires']) + self.build(trace({'id': 's1', 'op': 'extrude', 'profile': profile, + 'parameters': {'direction': (0, 0, -1), 'distance': 3}}), math.pi * 21 * 3) + + def test_clockwise_polygon_hole_is_subtractive(self): + profile = circle(5) + points = [(2, -1, 0), (-2, -1, 0), (-2, 1, 0), (2, 1, 0)] + profile['wires'].append({'edges': [{'kind': 'line', 'start': a, 'end': b} + for a, b in zip(points, points[1:] + points[:1])]}) + self.build(trace({'id': 's1', 'op': 'extrude', 'profile': profile, + 'parameters': {'direction': (0, 0, 1), 'distance': 3}}), (math.pi * 25 - 8) * 3) + + def test_explicit_boolean_cut(self): + self.build(trace({'id': 's1', 'op': 'box', 'parameters': {'length': 10, 'width': 10, 'height': 5}}, + {'id': 's2', 'op': 'cylinder', 'parameters': {'radius': 2, 'height': 5, 'origin': (5, 5, 0)}}, + {'id': 's3', 'op': 'cut', 'inputs': ['s1', 's2']}), 500 - math.pi * 20) + + def test_loft_circle_sections(self): + self.build(trace({'id': 's1', 'op': 'loft', 'profiles': [circle(2), circle(4, 6)], + 'parameters': {'ruled': True}}), math.pi * 6 * (4 + 8 + 16) / 3) + + def test_native_multisection_sweep(self): + self.build(trace({'id': 's1', 'op': 'sweep_multi', 'profiles': [circle(2), circle(4, 6)], + 'path': {'edges': [{'kind': 'line', 'start': (0, 0, 0), 'end': (0, 0, 6)}]}, + 'parameters': {'is_frenet': False}}), 56 * math.pi) + + def test_native_tapered_extrusion(self): + top_radius = 4 - 6 * math.tan(math.radians(15)) + self.build(trace({'id': 's1', 'op': 'extrude_taper', 'profile': circle(4), + 'parameters': {'direction': (0, 0, 6), 'taper': 15}}), + math.pi * 6 * (16 + 4 * top_radius + top_radius ** 2) / 3) + + def test_native_until_extrusion(self): + self.build(trace({'id': 's1', 'op': 'box', + 'parameters': {'length': 10, 'width': 10, 'height': 3, 'origin': (-5, -5, 5)}}, + {'id': 's2', 'op': 'extrude_until', 'inputs': ['s1'], 'profile': circle(1), + 'parameters': {'direction': (0, 0, 1), 'until': 'NEXT'}}), 5 * math.pi) + + def test_native_twisted_extrusion(self): + self.build(trace({'id': 's1', 'op': 'extrude_twist', 'profile': rectangle(), + 'parameters': {'normal': (0, 0, 4), 'center': (0, 0, 0), 'angle': 90}}), 240) + + def test_affine_shear_preserves_volume(self): + self.build(trace({'id': 's1', 'op': 'box', 'parameters': {'length': 10, 'width': 6, 'height': 4}}, + {'id': 's2', 'op': 'transform', 'inputs': ['s1'], 'parameters': {'matrix': [ + [1, .5, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]}}), 240) + + def test_both_split_preserves_original_component_order(self): + self.build(trace({'id': 's1', 'op': 'box', + 'parameters': {'length': 2, 'width': 3, 'height': 8}, + 'result': {'bbox': [0, 0, 0, 2, 3, 8], 'solid_count': 1}}, + {'id': 's2', 'op': 'split', 'inputs': ['s1'], + 'parameters': {'tool': {'origin': (0, 0, 2), 'normal': (0, 0, 1)}, 'keep': 'BOTH'}, + 'result_component_sides': ['BOTTOM', 'TOP']}, + {'id': 's3', 'op': 'component', 'inputs': ['s2'], 'parameters': {'index': 0}}), 12) + + def test_exact_ellipse_sketch(self): + profile = circle(2) + profile['wires'][0]['edges'] = [{'kind': 'ellipse', 'center': (0, 0, 0), + 'major_radius': 4, 'minor_radius': 2, 'x_dir': (1, 0, 0), 'y_dir': (0, 1, 0)}] + self.build(trace({'id': 's1', 'op': 'extrude', 'profile': profile, + 'parameters': {'direction': (0, 0, 1), 'distance': 3}}), math.pi * 8 * 3) + + def test_translate_preserves_volume(self): + self.build(trace({'id': 's1', 'op': 'sphere', 'parameters': {'radius': 3}}, + {'id': 's2', 'op': 'translate', 'inputs': ['s1'], 'parameters': {'vector': (5, -8, 2)}}), 36 * math.pi) + + def test_partial_cylinder(self): + self.build(trace({'id': 's1', 'op': 'cylinder', + 'parameters': {'radius': 3, 'height': 4, 'angle': 180}}), 18 * math.pi) + + def test_partial_cone(self): + self.build(trace({'id': 's1', 'op': 'cone', + 'parameters': {'base_radius': 3, 'top_radius': 0, 'height': 4, 'angle': 90}}), 3 * math.pi) + + def test_partial_sphere(self): + self.build(trace({'id': 's1', 'op': 'sphere', + 'parameters': {'radius': 3, 'angle1': 0, 'angle2': 90, 'angle3': 360}}), 18 * math.pi) + + def test_closed_rational_spline_profile(self): + profile = circle(1) + poles = [(1, 0, 0), (1, 1, 0), (0, 1, 0), (-1, 1, 0), (-1, 0, 0), + (-1, -1, 0), (0, -1, 0), (1, -1, 0), (1, 0, 0)] + profile['wires'][0]['edges'] = [{'kind': 'bspline', 'poles': poles, 'degree': 2, + 'knots': [0, .25, .5, .75, 1], 'multiplicities': [3, 2, 2, 2, 3], + 'weights': [1, math.sqrt(.5), 1, math.sqrt(.5), 1, math.sqrt(.5), 1, math.sqrt(.5), 1], + 'start': poles[0], 'end': poles[-1]}] + self.build(trace({'id': 's1', 'op': 'extrude', 'profile': profile, + 'parameters': {'direction': [0, 0, 1], 'distance': 2}}), 2 * math.pi) + + def test_reversed_cubic_basis_preserves_entire_curve(self): + profile = circle(1) + poles = [(0, 0, 0), (0, 3, 0), (2, 4, 0), (4, 0, 0)] + profile['wires'][0]['edges'] = [{'kind': 'bezier', 'poles': poles, 'degree': 3, + 'start': poles[-1], 'end': poles[0], 'reversed': True}, + {'kind': 'line', 'start': poles[0], 'end': poles[-1]}] + # Exact Green-integral area of this cubic and its closing chord is 7.5. + self.build(trace({'id': 's1', 'op': 'extrude', 'profile': profile, + 'parameters': {'direction': [0, 0, 1], 'distance': 2}}), 15) + + def test_multi_body_is_complete_assembly(self): + payload = trace({'id': 's1', 'op': 'box', 'parameters': {'length': 2, 'width': 3, 'height': 4}}, + {'id': 's2', 'op': 'box', 'parameters': {'length': 4, 'width': 2, 'height': 3, 'origin': [20, 0, 0]}}, + {'id': 's3', 'op': 'compound', 'inputs': ['s1', 's2']}) + payload['solid_count'] = 2 + self.build(payload, 48) + source, meta = replay_trace_to_ftc(payload) + self.assertEqual(meta['artifact_type'], 'assembly') + self.assertIn('@scad.assemble(', source) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_build123d_unknown_api.py b/test/test_build123d_unknown_api.py new file mode 100644 index 00000000..3d77ccf6 --- /dev/null +++ b/test/test_build123d_unknown_api.py @@ -0,0 +1,39 @@ +"""Unknown construction must remain visible instead of aliasing an old solid.""" +from pathlib import Path +import sys + +import pytest + +pytest.importorskip("build123d") +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tools/research/build123dftc")) +from b3ftc.replay import replay_trace_to_ftc +from b3ftc.tracer import trace_source +from b3ftc.validation import compare_metrics + + +@pytest.mark.parametrize("statement", [ + "result = Box(2,3,4).to_splines()", + "from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox\nresult = Solid(BRepPrimAPI_MakeBox(2,3,4).Solid())", +]) +def test_uninstrumented_api_cannot_silently_accept(statement): + trace = trace_source("from build123d import *\n" + statement) + assert trace["b3d_status"] == "ok", trace["error"] + assert trace["unsupported"], trace + assert any(step["op"] == "unsupported" for step in trace["steps"]) + _, metadata = replay_trace_to_ftc(trace) + assert metadata["status"] == "partial", metadata + actual = {"status": "ok", "volume": trace["b3d_volume"], + "bbox": trace["b3d_bbox"], "solid_count": trace["solid_count"], + "body_count": trace["solid_count"], "is_valid": True} + assert compare_metrics(trace, actual, metadata)["quality"] == "rejected" + + +def test_failed_source_rejects_even_after_valid_feature_was_created(): + trace = trace_source("from build123d import *\nresult=Box(2,3,4)\nraise RuntimeError('unknown operation')") + _, metadata = replay_trace_to_ftc(trace) + actual = {"status": "ok", "volume": 24, "bbox": [-1,-1.5,-2,1,1.5,2], + "solid_count": 1, "body_count": 1, "is_valid": True} + result = compare_metrics(trace, actual, metadata) + assert result["quality"] == "rejected" + assert "source_failed" in result["reasons"] diff --git a/test/test_build123d_validation.py b/test/test_build123d_validation.py new file mode 100644 index 00000000..94c55faf --- /dev/null +++ b/test/test_build123d_validation.py @@ -0,0 +1,244 @@ +"""Acceptance must reject missing evidence and geometric false positives.""" +from __future__ import annotations + +import json +import math +from pathlib import Path +import sys + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tools/research/build123dftc")) +from b3ftc.validation import compare_metrics, validate_directory, validate_row + + +def expected(**changes): + trace = {"b3d_status": "ok", "b3d_volume": 1000.0, + "b3d_bbox": [-5, -5, 0, 5, 5, 10], "solid_count": 1, + "result_refs": ["s1"], "unsupported": []} + trace.update(changes) + return trace + + +def actual(**changes): + metrics = {"status": "ok", "volume": 1000.0, + "bbox": [-5, -5, 0, 5, 5, 10], "solid_count": 1, + "body_count": 1, "is_valid": True} + metrics.update(changes) + return metrics + + +META = {"status": "ok", "unsupported": []} + + +def test_matching_metrics_accepted(): + result = compare_metrics(expected(), actual(), META) + assert result["quality"] == "accepted", result + assert result["bbox_error"] == 0 + + +def test_reference_failure_reports_basic_geometry_separately(tmp_path, monkeypatch): + import b3ftc.validation as validation + ftc = tmp_path / "sample.ftc.py" + ftc.write_text("# worker is isolated by this test") + trace = tmp_path / "sample.trace.json" + trace.write_text(json.dumps(expected())) + ftc.with_name("sample.meta.json").write_text(json.dumps(META)) + monkeypatch.setattr(validation, "_worker", lambda *args, **kwargs: + actual(reference_status="error", reference_error="kernel comparison failed")) + row = validate_row(ftc, trace, reference_step=tmp_path / "reference.step") + assert row["quality"] == "rejected" + assert row["metrics_quality"] == "accepted" + assert row["metrics_reasons"] == [] + assert row["reasons"] == ["reference_error"] + + +def test_rational_circle_cylinder_has_mathematical_area_four_pi(): + from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeEdge, BRepBuilderAPI_MakeWire, BRepBuilderAPI_MakeFace + from OCP.BRepPrimAPI import BRepPrimAPI_MakePrism + from OCP.Geom import Geom_Circle + from OCP.GeomConvert import GeomConvert + from OCP.gp import gp_Ax2, gp_Pnt, gp_Dir, gp_Vec + from b3ftc._validate_worker import _area, _volume + + circle = Geom_Circle(gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)), 1) + spline = GeomConvert.CurveToBSplineCurve_s(circle) + assert spline.IsRational() + edge = BRepBuilderAPI_MakeEdge(spline).Edge() + wire = BRepBuilderAPI_MakeWire(edge).Wire() + face = BRepBuilderAPI_MakeFace(wire, True).Face() + solid = BRepPrimAPI_MakePrism(face, gp_Vec(0, 0, 1)).Shape() + # OCCT 7.9's continuity split adds about 7.7e-9 relative integration + # error here; this precision still detects the original 0.0028 error. + assert _area(solid) == pytest.approx(4 * math.pi, rel=1e-8) + assert _volume(solid) == pytest.approx(math.pi, rel=1e-9) + + +def test_reference_export_cannot_change_geometry_to_obtain_acceptance(): + metrics = actual(reference_status="ok", reference_volume=1000, + symmetric_difference_volume=0, roundtrip_actual_volume=900, + roundtrip_actual_bbox=[-5, -5, 0, 5, 5, 10], + roundtrip_actual_solid_count=1, roundtrip_actual_valid=True) + row = compare_metrics(expected(), metrics, META, require_reference=True) + assert row["quality"] == "rejected" + assert "reference_roundtrip_changed_geometry" in row["reasons"] + + +@pytest.mark.parametrize("changes", [ + {"b3d_status": "error"}, {"b3d_volume": None}, {"b3d_bbox": None}, + {"solid_count": None}, {"result_refs": []}, {"b3d_volume": math.nan}, + {"b3d_bbox": [0, 0, 0]}, {"unsupported": ["unsupported sweep"]}, +]) +def test_source_failure_or_missing_evidence_rejected(changes): + assert compare_metrics(expected(**changes), actual(), META)["quality"] == "rejected" + + +@pytest.mark.parametrize("metadata", [None, {}, {"status": "partial"}, + {"status": "ok", "unsupported": ["torus"]}, + {"status": "ok", "unknown": ["operation"]}, + {"status": "ok", "unknown_operations": 1}]) +def test_incomplete_conversion_never_accepted(metadata): + assert compare_metrics(expected(), actual(), metadata)["quality"] == "rejected" + + +@pytest.mark.parametrize("changes", [ + {"body_count": 0}, {"solid_count": 2}, {"is_valid": False}, + {"volume": None}, {"bbox": None}, {"volume": math.inf}, + {"bbox": [0, -5, 0, 10, 5, 10]}, +]) +def test_actual_failure_including_rigid_translation_rejected(changes): + assert compare_metrics(expected(), actual(**changes), META)["quality"] == "rejected" + + +def write_case(root: Path, stem: str, source: str, trace=None, metadata=None): + ftc_dir, traces_dir = root / "ftc", root / "traces" + ftc_dir.mkdir(exist_ok=True) + traces_dir.mkdir(exist_ok=True) + ftc = ftc_dir / (stem + ".ftc.py") + ftc.write_text(source) + trace_path = traces_dir / (stem + ".trace.json") + trace_path.write_text(json.dumps(trace or expected())) + ftc.with_name(stem + ".meta.json").write_text(json.dumps(metadata or META)) + return ftc, trace_path + + +def box_source(center_x=0): + return f'''from pathlib import Path +import simplecadapi as scad +BODIES = None +@scad.part(id='validation-box', project_root=Path(__file__).parent) +def build(): + global BODIES + body = scad.make_box_rsolid(10, 10, 10, bottom_face_center=({center_x}, 0, 0)) + BODIES = [body] + return body +''' + + +def test_worker_builds_real_topology_and_checks_position(tmp_path): + ftc, trace = write_case(tmp_path, "box", box_source()) + row = validate_row(ftc, trace, timeout=30) + assert row["quality"] == "accepted", row + assert row["ftc_solid_count"] == 1 + ftc.write_text(box_source(10)) + row = validate_row(ftc, trace, timeout=30) + assert row["quality"] == "rejected", row + assert "bbox_mismatch" in row["reasons"] + + +def test_no_bodies_cannot_fall_back_to_returned_part(tmp_path): + source = box_source().replace("BODIES = [body]", "BODIES = []") + ftc, trace = write_case(tmp_path, "empty", source) + row = validate_row(ftc, trace, timeout=30) + assert row["quality"] == "rejected", row + assert "empty_bodies" in row["reasons"] + + +def test_timeout_and_build_failure_do_not_stop_batch(tmp_path): + write_case(tmp_path, "a_timeout", "import time\ntime.sleep(100)\n") + write_case(tmp_path, "b_failure", "raise RuntimeError('model failure')\n") + write_case(tmp_path, "c_good", box_source()) + report = validate_directory(tmp_path / "ftc", tmp_path / "traces", timeout=8) + assert [row["quality"] for row in report["rows"]] == ["rejected", "rejected", "accepted"], report + assert report["rows"][0]["build"] == "timeout" + assert "model failure" in report["rows"][1]["error"] + + +def test_missing_trace_rejected_but_other_cases_continue(tmp_path): + ftc, trace = write_case(tmp_path, "a_missing", box_source()) + trace.unlink() + write_case(tmp_path, "b_good", box_source()) + report = validate_directory(ftc.parent, tmp_path / "traces", timeout=30) + assert report["counts"] == {"accepted": 1, "partial": 0, "rejected": 1} + + +def test_reference_step_detects_equal_volume_equal_bbox_different_holes(tmp_path): + from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut + from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox, BRepPrimAPI_MakeCylinder + from OCP.gp import gp_Pnt, gp_Ax2, gp_Dir + from OCP.STEPControl import STEPControl_Writer, STEPControl_AsIs + from OCP.IFSelect import IFSelect_RetDone + + box = BRepPrimAPI_MakeBox(gp_Pnt(-5, -5, 0), 10, 10, 10).Shape() + hole = BRepPrimAPI_MakeCylinder(gp_Ax2(gp_Pnt(2, 0, 0), gp_Dir(0, 0, 1)), 1, 10).Shape() + reference = BRepAlgoAPI_Cut(box, hole).Shape() + step = tmp_path / "reference.step" + writer = STEPControl_Writer() + assert writer.Transfer(reference, STEPControl_AsIs) == IFSelect_RetDone + assert writer.Write(str(step)) == IFSelect_RetDone + source = box_source().replace("BODIES = [body]", "body = scad.cut_rsolid(body, scad.make_cylinder_rsolid(1, 10, bottom_face_center=(-2, 0, 0)))\n BODIES = [body]") + ftc, trace = write_case(tmp_path, "wrong_hole", source, + expected(b3d_volume=1000 - math.pi * 10)) + coarse = validate_row(ftc, trace, timeout=30) + assert coarse["quality"] == "accepted", coarse + strict = validate_row(ftc, trace, timeout=30, reference_step=step) + assert strict["quality"] == "rejected", strict + assert "symmetric_difference_mismatch" in strict["reasons"] + assert strict["symmetric_difference_volume"] > 60 + independent = validate_row(ftc, trace, timeout=30, reference_step=step, + reference_python=sys.executable) + assert independent["quality"] == "rejected", independent + assert independent["reference_kernel"] + assert "symmetric_difference_mismatch" in independent["reasons"] + ftc.write_text(source.replace("bottom_face_center=(-2, 0, 0)", "bottom_face_center=(2, 0, 0)")) + identical = validate_row(ftc, trace, timeout=30, reference_step=step, + reference_python=sys.executable) + assert identical["quality"] == "accepted", identical + assert identical["symmetric_difference_volume"] == pytest.approx(0) + + +def test_requested_missing_reference_rejected(tmp_path): + ftc, trace = write_case(tmp_path, "box", box_source()) + row = validate_row(ftc, trace, timeout=30, reference_step=tmp_path / "absent.step") + assert row["quality"] == "rejected", row + assert "reference_error" in row["reasons"] + + +@pytest.mark.parametrize("returned", ["None", "scad.make_box_rsolid(1, 1, 1)", + "scad.translate_shape(body, (10, 0, 0))"]) +def test_actual_build_return_cannot_hide_behind_matching_bodies(tmp_path, returned): + source = box_source().replace("return body", f"return {returned}") + # A plain build allows None so the worker itself must reject it. + source = "\n".join(line for line in source.splitlines() if not line.startswith("@scad.part")) + ftc, trace = write_case(tmp_path, "wrong_return", source) + row = validate_row(ftc, trace, timeout=30) + assert row["quality"] == "rejected", row + + +def test_returned_assembly_is_checked_in_world_coordinates(tmp_path): + source = """import simplecadapi as scad +BODIES = None +def build(): + global BODIES + body = scad.make_box_rsolid(10, 10, 10) + BODIES = [body] + part = scad.make_part_rpart(part_id='box', body=body) + assembly = scad.make_assembly_rassembly(assembly_id='placed') + return scad.add_component_rassembly(assembly=assembly, item=part, + component_id='box', placement=scad.make_placement_rplacement(origin=(10,0,0))) +""" + ftc, trace = write_case(tmp_path, "placed", source) + row = validate_row(ftc, trace, timeout=30) + assert row["quality"] == "rejected", row + assert "does not match" in row["error"] diff --git a/test/test_deformation_features.py b/test/test_deformation_features.py new file mode 100644 index 00000000..88088d40 --- /dev/null +++ b/test/test_deformation_features.py @@ -0,0 +1,97 @@ +"""Geometric and graph-replay contracts needed by source translators.""" +import math + +import pytest +import simplecadapi as scad + + +def test_nonuniform_scale_volume_and_replay(): + with scad.GraphSession(graph_id="scale-test") as session: + original = scad.make_box_rsolid(width=10, height=12, depth=14) + scaled = scad.scale_rsolid(solid=original, factors=(2, 3, 0.5), center=(5, 6, 7)) + session.capture_result(value=scaled) + assert scaled.get_volume() == pytest.approx(original.get_volume() * 3) + assert original.get_volume() == pytest.approx(1680) + rebuilt = scad.replay_model_json(scad.export_model_json(session=session), strict=True)[0] + assert rebuilt.get_volume() == pytest.approx(scaled.get_volume()) + + +@pytest.mark.parametrize("factors", [(0, 1, 1), (math.nan, 1, 1), (1, 2), (math.inf, 1, 1)]) +def test_invalid_scale_factors_are_rejected(factors): + original = scad.make_box_rsolid(width=10, height=12, depth=14) + with pytest.raises(ValueError): + scad.scale_rsolid(solid=original, factors=factors) + + +@pytest.mark.parametrize("amount", [-1.0, 1.0]) +def test_signed_open_shell_replays(amount): + with scad.GraphSession(graph_id="offset-test") as session: + original = scad.make_box_rsolid(width=10, height=12, depth=14) + openings = scad.ql.faces().where(scad.ql.prop("geom.normal.z", ">", 0.9)).exactly(1) + hollow = scad.offset_rsolid(solid=original, amount=amount, openings=openings) + session.capture_result(value=hollow) + assert 0 < hollow.get_volume() < original.get_volume() + rebuilt = scad.replay_model_json(scad.export_model_json(session=session), strict=True)[0] + assert rebuilt.get_volume() == pytest.approx(hollow.get_volume(), rel=1e-9) + + +def test_closed_outer_offset_increases_volume(): + original = scad.make_box_rsolid(width=10, height=12, depth=14) + expanded = scad.offset_rsolid(solid=original, amount=1.0) + assert expanded.get_volume() > original.get_volume() + + +def test_zero_offset_rejected(): + original = scad.make_box_rsolid(width=10, height=12, depth=14) + with pytest.raises(ValueError): + scad.offset_rsolid(solid=original, amount=0) + + +def test_affine_shear_is_recorded_and_replayed(): + with scad.GraphSession(graph_id="shear") as session: + original = scad.make_box_rsolid(width=10, height=12, depth=14) + transformed = scad.transform_rsolid(solid=original, + matrix=[[1, 0.3, 0, 5], [0, 1, 0, 2], [0, 0, 1, 0], [0, 0, 0, 1]]) + session.capture_result(value=transformed) + assert transformed.get_volume() == pytest.approx(original.get_volume()) + rebuilt = scad.replay_model_json(scad.export_model_json(session=session), strict=True)[0] + assert rebuilt.get_volume() == pytest.approx(transformed.get_volume()) + + +def test_affine_singular_matrix_rejected(): + original = scad.make_box_rsolid(width=10, height=12, depth=14) + with pytest.raises(ValueError): + scad.transform_rsolid(solid=original, matrix=[[0]*4 for _ in range(4)]) + + +def test_set_boolean_keeps_all_output_slots_and_part_replay(): + with scad.GraphSession(graph_id="cut-pieces") as session: + base = scad.make_box_rsolid(10, 2, 2) + tool = scad.make_box_rsolid(2, 4, 4, bottom_face_center=(0, 0, -1)) + pieces = scad.boolean_rsolidlist(left=[base], right=[tool], operation="cut") + assert len(pieces) == 2 + final = scad.make_part_rpart(part_id="second", body=pieces[1]) + session.capture_result(value=final) + replayed = scad.replay_model_json(scad.export_model_json(session=session), strict=True)[0] + from simplecadapi.kernel.ocp_properties import center_of_mass + assert tuple(center_of_mass(replayed.body.wrapped)) == pytest.approx(tuple(center_of_mass(pieces[1].wrapped))) + assert replayed.body.get_volume() == pytest.approx(16) + + +@pytest.mark.parametrize("operation", ["cut", "intersect", "union"]) +def test_set_boolean_compound_members_and_graph_replay(operation): + with scad.GraphSession(graph_id="set-boolean") as session: + left = [scad.make_box_rsolid(2, 2, 2, bottom_face_center=(x, 0, 0)) for x in (-4, 4)] + right = [scad.make_box_rsolid(1, 4, 4, bottom_face_center=(x, 0, -1)) for x in (-4, 4)] + result = scad.boolean_rsolidlist(left=left, right=right, operation=operation) + session.capture_result(value=result) + expected = {"cut": 8, "intersect": 8, "union": 40}[operation] + assert sum(body.get_volume() for body in result) == pytest.approx(expected) + replayed = scad.replay_model_json(scad.export_model_json(session=session), strict=True) + assert len(replayed) == len(result) + assert sum(body.get_volume() for body in replayed) == pytest.approx(expected) + + +def test_set_boolean_complete_removal_returns_no_solid(): + base = scad.make_box_rsolid(2, 2, 2) + assert scad.boolean_rsolidlist(left=[base], right=[base], operation="cut") == [] diff --git a/test/test_draft.py b/test/test_draft.py new file mode 100644 index 00000000..68ba2828 --- /dev/null +++ b/test/test_draft.py @@ -0,0 +1,60 @@ +"""Recorded draft preserves its selected faces and neutral-plane semantics.""" +import math + +import pytest +from OCP.BRepCheck import BRepCheck_Analyzer + +import simplecadapi as s +from simplecadapi import ql +from simplecadapi.operators.draft import draft_rsolid +from simplecadapi.recording.graph import GraphSession + + +def _right_face(body): + return next(face for face in body._iter_faces() if face.get_normal_at().x > .9) + + +@pytest.mark.parametrize("angle", [10, -10, 0]) +def test_single_planar_face_uses_neutral_plane_and_signed_degrees(angle): + body = s.make_box_rsolid(10, 10, 10) + result = draft_rsolid(body, [_right_face(body)], angle=angle) + assert result.get_volume() == pytest.approx(1000 - 500 * math.tan(math.radians(angle)), rel=1e-9) + assert body.get_volume() == pytest.approx(1000) + assert BRepCheck_Analyzer(result.wrapped).IsValid() + + +def test_query_selection_has_same_geometry_as_explicit_faces(): + body = s.make_box_rsolid(10, 10, 10) + selector = ql.faces().where(ql.prop("geom.normal.x", ">", .9)).exactly(1) + selected = draft_rsolid(body, selector, 5, plane_origin=(0, 0, 5)) + explicit = draft_rsolid(body, [_right_face(body)], 5, plane_origin=(0, 0, 5)) + assert selected.get_volume() == pytest.approx(explicit.get_volume(), rel=1e-9) + assert selected.get_volume() == pytest.approx(1000) + + +def test_draft_face_selection_and_plane_are_replayable(): + with GraphSession() as session: + body = s.make_box_rsolid(10, 10, 10) + result = draft_rsolid(body, [_right_face(body)], 10) + session.capture_result(value=result) + node = next(node for node in session.graph.nodes if node.op == "make_draft_rsolid") + assert node.params["angle"] == 10 + assert node.params["selected_face_count"] == 1 + assert len(node.params["selected_face_node_ids"]) == 1 + assert len(node.inputs) == 2 + replayed = s.replay_model_json(s.export_model_json(session))[0] + assert replayed.get_volume() == pytest.approx(result.get_volume(), rel=1e-9) + + +def test_invalid_selection_plane_and_angle_are_rejected(): + body = s.make_box_rsolid(10, 10, 10) + faces = [_right_face(body)] + other = s.make_box_rsolid(1, 1, 1, bottom_face_center=(20, 0, 0)) + with pytest.raises(ValueError, match="belong"): + draft_rsolid(body, [_right_face(other)], 5) + with pytest.raises(ValueError, match="at least one"): + draft_rsolid(body, [], 5) + with pytest.raises(ValueError, match="nonzero"): + draft_rsolid(body, faces, 5, plane_normal=(0, 0, 0)) + with pytest.raises(ValueError, match="angle"): + draft_rsolid(body, faces, 90) diff --git a/test/test_error_diagnostics_blend_ql.py b/test/test_error_diagnostics_blend_ql.py index eb63e8b1..d6a1efee 100644 --- a/test/test_error_diagnostics_blend_ql.py +++ b/test/test_error_diagnostics_blend_ql.py @@ -132,8 +132,7 @@ def test_fillet_bore_mouth_boundary_room(): def test_fillet_silent_garbage_output_caught_at_exit(): # Mechanism E: r=5 on all 12 edges of a 10-cube fails loudly, but r=6 - # makes the kernel *succeed* and hand back a solid with volume 1036.35 - # — more material than the 1000 it started with. Geometrically + # makes the kernel *succeed* and hand back a degenerate solid. Geometrically # impossible; the exit check must name it instead of returning it. box = _box() edges = _box_edges(box) @@ -141,17 +140,23 @@ def test_fillet_silent_garbage_output_caught_at_exit(): scad.fillet_rsolid(box, edges, 6) payload = _payload(ctx.value) + what = payload["what_happened"] # The volume violation leads what_happened so the agent can tell - # "kernel silently lied" apart from "kernel refused" (r=5 path). The - # garbage volume itself is platform-dependent OCC behavior (macOS - # reports ~1036, Linux ~1039) — the contract is only that the kernel - # handed back MORE material than the 1000 it was given. - garbage = re.search(r"result volume ([0-9.]+)", payload["what_happened"]) - assert garbage, payload["what_happened"] - assert float(garbage.group(1)) > 1000 - assert "exceeds the input volume 1000" in payload["what_happened"] + # "kernel silently lied" apart from "kernel refused" (r=5 path). How the + # garbage solid measures depends on the volume integrator: the fixed-order + # one reported phantom extra material (~1036 on macOS, ~1039 on Linux, more + # than the 1000 it was given); the knot-span (Gauss-Kronrod) one sees an + # empty solid (volume 0). Either way the exit check must name it. + garbage = re.search(r"result volume (?:is )?([0-9.]+)", what) + assert garbage, what + volume = float(garbage.group(1)) + if volume > 1000: + assert "exceeds the input volume 1000" in what + else: + assert volume == 0.0 + assert "empty/degenerate solid" in what # Probe explanation follows as the suspected root cause. - assert "probes indicate" in payload["what_happened"] + assert "probes indicate" in what assert "BlendVolumeViolation" in (payload["technical_details"] or "") diff --git a/test/test_limited_extrusion.py b/test/test_limited_extrusion.py new file mode 100644 index 00000000..4b1047cd --- /dev/null +++ b/test/test_limited_extrusion.py @@ -0,0 +1,95 @@ +"""Target-limited extrusions must terminate on actual target surfaces.""" +from __future__ import annotations + +import json +import pytest +from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut + +import simplecadapi as s +from simplecadapi.kernel.ocp_booleans import solids_of +from simplecadapi.kernel.ocp_properties import center_of_mass, volume +from simplecadapi.operators.limited_extrusion import extrude_until_rsolid +from simplecadapi.recording.graph import GraphSession + + +@pytest.mark.parametrize("until,height", [("NEXT", 5), ("LAST", 7)]) +def test_forward_stops_at_near_or_far_planar_surface(until, height): + face = s.make_rectangle_rface(2, 2) + target = s.make_box_rsolid(10, 10, 2, bottom_face_center=(0, 0, 5)) + output = extrude_until_rsolid(face, target, until=until) + assert output.get_volume() == pytest.approx(4 * height) + + +@pytest.mark.parametrize("until,height", [("PREVIOUS", 8), ("FIRST", 10)]) +def test_reverse_modes_invert_the_direction(until, height): + face = s.make_rectangle_rface(2, 2, center=(0, 0, 10)) + target = s.make_box_rsolid(10, 10, 2) + output = extrude_until_rsolid(face, target, until=until) + assert output.get_volume() == pytest.approx(4 * height) + + +def test_curved_termination_matches_an_independent_boolean_reference(): + face = s.make_rectangle_rface(2, 2) + sphere = s.make_sphere_rsolid(5, center=(0, 0, 10)) + output = extrude_until_rsolid(face, sphere) + long_prism = s.extrude_rsolid(face, direction=(0, 0, 1), distance=20) + cut = BRepAlgoAPI_Cut(long_prism.wrapped, sphere.wrapped) + cut.Build() + candidates = solids_of(cut.Shape()) + lower = min(candidates, key=lambda part: center_of_mass(part).z) + assert output.get_volume() == pytest.approx(volume(lower), rel=1e-8) + # A sphere's contact surface bows away from its bounding box near the axis. + assert output.get_volume() > 4 * 5 + .1 + + +def test_ordered_multi_body_targets_choose_first_and_last_surface(): + face = s.make_rectangle_rface(2, 2) + lower = s.make_box_rsolid(10, 10, 2, bottom_face_center=(0, 0, 5)) + upper = s.make_box_rsolid(10, 10, 2, bottom_face_center=(0, 0, 10)) + assert extrude_until_rsolid(face, [upper, lower], until="NEXT").get_volume() == pytest.approx(20) + assert extrude_until_rsolid(face, [upper, lower], until="LAST").get_volume() == pytest.approx(48) + + +def test_rejects_invalid_parameters_and_non_intersecting_targets(): + face = s.make_rectangle_rface(2, 2) + far = s.make_box_rsolid(2, 2, 2, bottom_face_center=(20, 0, 5)) + with pytest.raises(ValueError, match="intersect|contact"): + extrude_until_rsolid(face, far) + with pytest.raises(ValueError, match="nonzero"): + extrude_until_rsolid(face, far, direction=(0, 0, 0)) + with pytest.raises(ValueError, match="NEXT"): + extrude_until_rsolid(face, far, until="UNKNOWN") + with pytest.raises(ValueError, match="at least one"): + extrude_until_rsolid(face, []) + + +def test_operation_retains_profile_and_target_as_replay_inputs(): + with GraphSession() as session: + face = s.make_rectangle_rface(2, 2) + target = s.make_box_rsolid(10, 10, 2, bottom_face_center=(0, 0, 5)) + output = extrude_until_rsolid(face, target) + session.capture_result(value=output) + node = next(n for n in session.graph.nodes if n.op == "make_extrude_until_rsolid") + assert len(node.inputs) == 2 + assert {key: value for key, value in node.params.items() if key != "input_refs"} == { + "direction": (0, 0, 1), "until": "NEXT", "target_count": 1} + assert [ref["node_id"] for ref in node.params["input_refs"]] == [n.node_id for n in node.inputs] + assert [ref["output_slot"] for ref in node.params["input_refs"]] == [0, 0] + replayed = s.replay_model_json(s.export_model_json(session))[0] + assert replayed.get_volume() == pytest.approx(output.get_volume(), rel=1e-9) + assert replayed.get_volume() == pytest.approx(20) + + +@pytest.mark.parametrize("until,height", [("NEXT", 5), ("LAST", 7)]) +def test_matching_target_footprint_keeps_distinct_termination_faces(until, height): + profile = s.make_rectangle_rface(2, 2) + target = s.make_box_rsolid(2, 2, 2, bottom_face_center=(0, 0, 5)) + result = extrude_until_rsolid(profile, target, until=until) + assert result.get_volume() == pytest.approx(4 * height) + + +def test_partial_target_cannot_silently_leave_the_temporary_prism(): + profile = s.make_rectangle_rface(4, 4) + target = s.make_box_rsolid(2, 2, 2, bottom_face_center=(0, 0, 5)) + with pytest.raises(ValueError, match="cover|termination"): + extrude_until_rsolid(profile, target) diff --git a/test/test_ql.py b/test/test_ql.py index 56328ce6..2d6c9955 100644 --- a/test/test_ql.py +++ b/test/test_ql.py @@ -6,6 +6,14 @@ class TestQLTagPredicates(unittest.TestCase): + def test_solid_world_bounds_distinguish_equal_volume_components(self): + first = scad.make_box_rsolid(2, 2, 2, bottom_face_center=(3, 0, 4)) + second = scad.make_box_rsolid(2, 2, 2, bottom_face_center=(8, 0, 4)) + selector = Q.solids().where(Q.and_( + Q.prop("geom.bbox.min.x", "==", 7), + Q.prop("geom.bbox.max.z", "==", 6))).exactly(1) + self.assertEqual(selector.resolve([first, second]), [second]) + def test_tag_exact_and_wildcard(self): box = scad.make_box_rsolid(1.0, 1.0, 1.0) scad.apply_tag(box, "role.mounting_surface") diff --git a/test/test_rational_volume_precision.py b/test/test_rational_volume_precision.py new file mode 100644 index 00000000..86bc7634 --- /dev/null +++ b/test/test_rational_volume_precision.py @@ -0,0 +1,17 @@ +"""Rational NURBS mass properties must match analytic geometry.""" +import math + +import pytest +import simplecadapi as s + + +def test_nurbs_circle_extrusion_uses_span_aware_volume_integration(): + sketch = s.make_sketch_rsketch(name="rational-circle", plane="XY") + sketch = s.add_point_rsketch(sketch=sketch, point_id="seam", x=1, y=0) + poles = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1), (1, 0)] + sketch = s.add_bspline_rsketch(sketch=sketch, entity_id="circle", start="seam", end="seam", + control_points=poles, degree=2, knots=[0, .25, .5, .75, 1], + multiplicities=[3, 2, 2, 2, 3], weights=[1, math.sqrt(.5), 1, math.sqrt(.5), 1, math.sqrt(.5), 1, math.sqrt(.5), 1]) + profile = s.make_face_from_sketch_rface(sketch=sketch) + body = s.extrude_rsolid(profile=profile, direction=(0, 0, 1), distance=2) + assert body.get_volume() == pytest.approx(2 * math.pi, rel=1e-9) diff --git a/test/test_section_features.py b/test/test_section_features.py new file mode 100644 index 00000000..1ce5caa3 --- /dev/null +++ b/test/test_section_features.py @@ -0,0 +1,105 @@ +"""Native section features: strict geometry and graph replay.""" +import math +import pytest +import simplecadapi as s + + +def _rectangle(z, width=10, height=6): + sketch = s.make_sketch_rsketch(name=f"section{z}", plane={"origin": (0, 0, z), "x_axis": (1, 0, 0), "y_axis": (0, 1, 0)}) + for name, point in zip("abcd", [(0, 0), (width, 0), (width, height), (0, height)]): + sketch = s.add_point_rsketch(sketch=sketch, point_id=name, x=point[0], y=point[1]) + for name, first, second in [("ab", "a", "b"), ("bc", "b", "c"), ("cd", "c", "d"), ("da", "d", "a")]: + sketch = s.add_line_rsketch(sketch=sketch, entity_id=name, start=first, end=second) + return s.make_face_from_sketch_rface(sketch=sketch) + + +def test_tapered_rectangle_and_graph_replay(): + with s.GraphSession(graph_id="taper") as session: + profile = _rectangle(0) + body = s.extrude_taper_rsolid(profile=profile, vector=(0, 0, 4), taper=10) + session.capture_result(value=body) + slope = math.tan(math.radians(10)) + expected = 60 * 4 - (10 + 6) * slope * 4**2 + 4 * slope**2 * 4**3 / 3 + assert body.get_volume() == pytest.approx(expected, rel=1e-8) + replayed = s.replay_model_json(s.export_model_json(session=session), strict=True)[0] + assert replayed.get_volume() == pytest.approx(expected, rel=1e-8) + + +def test_multisection_straight_sweep_and_replay(): + with s.GraphSession(graph_id="multi") as session: + sections = [_rectangle(0), _rectangle(3), _rectangle(6)] + path = s.make_segment_rwire(start=(5, 3, 0), end=(5, 3, 6)) + body = s.sweep_multisection_rsolid(profiles=sections, path=path) + session.capture_result(value=body) + assert body.get_volume() == pytest.approx(360, rel=1e-6) + replayed = s.replay_model_json(s.export_model_json(session=session), strict=True)[0] + assert replayed.get_volume() == pytest.approx(360, rel=1e-6) + + +def test_multisection_needs_two_sections(): + with pytest.raises(ValueError): + s.sweep_multisection_rsolid(profiles=[_rectangle(0)], path=s.make_segment_rwire(start=(0, 0, 0), end=(0, 0, 3))) + + +def test_invalid_taper_is_rejected(): + with pytest.raises(ValueError): + s.extrude_taper_rsolid(profile=_rectangle(0), vector=(0, 0, 4), taper=math.nan) + + +@pytest.mark.parametrize("taper,vector", [(-10, (0, 0, 4)), (10, (0, 0, -4))]) +def test_taper_fallback_keeps_exact_section_area(taper, vector): + body = s.extrude_taper_rsolid(profile=_rectangle(0), vector=vector, taper=taper) + slope = math.tan(math.radians(taper)) + expected = 60 * 4 - 16 * slope * 16 + 4 * slope**2 * 64 / 3 + assert body.get_volume() == pytest.approx(expected, rel=1e-7) + + +def test_taper_with_hole_tapers_inner_loop_oppositely(): + sketch = s.make_sketch_rsketch(name="annulus", plane="XY") + sketch = s.add_point_rsketch(sketch=sketch, point_id="center", x=0, y=0) + sketch = s.add_circle_rsketch(sketch=sketch, entity_id="outer", center="center", radius=10) + sketch = s.add_circle_rsketch(sketch=sketch, entity_id="inner", center="center", radius=2) + face = s.make_face_from_sketch_rface(sketch=sketch, profile="outer", inner_profiles=["inner"]) + body = s.extrude_taper_rsolid(profile=face, vector=(0, 0, 3), taper=5) + slope = math.tan(math.radians(5)) + expected = math.pi * ((100 - 4) * 3 - (10 + 2) * slope * 9) + assert body.get_volume() == pytest.approx(expected, rel=1e-6) + + +def test_taper_ql_face_is_recorded_as_feature_input(): + with s.GraphSession(graph_id="selected-taper") as session: + base = s.make_box_rsolid(10, 6, 2) + profile = s.ql.faces().where(s.ql.prop("geom.normal.z", ">", .9)).exactly(1).resolve(base)[0] + result = s.extrude_taper_rsolid(profile=profile, vector=(0, 0, 4), taper=10) + session.capture_result(value=result) + replayed = s.replay_model_json(s.export_model_json(session=session), strict=True)[0] + assert replayed.get_volume() == pytest.approx(result.get_volume(), rel=1e-8) + from simplecadapi.kernel.ocp_properties import center_of_mass + assert tuple(center_of_mass(replayed.wrapped)) == pytest.approx(tuple(center_of_mass(result.wrapped))) + + +def test_multisection_uses_ordered_slots_from_one_boundary_node(): + with s.GraphSession(graph_id="boundary-sweep") as session: + first = s.make_circle_rwire(center=(0, 0, 0), radius=2) + last = s.make_circle_rwire(center=(0, 0, 6), radius=3) + shell = s.loft_rshell(sections=[first, last]) + boundaries = s.free_boundaries_rwirelist(shell) + assert len(boundaries) == 2 + path = s.make_segment_rwire(start=(0, 0, 0), end=(0, 0, 6)) + body = s.sweep_multisection_rsolid(profiles=list(reversed(boundaries)), path=path) + session.capture_result(value=body) + replayed = s.replay_model_json(s.export_model_json(session=session), strict=True)[0] + assert replayed.get_volume() == pytest.approx(body.get_volume(), rel=1e-7) + + +def test_taper_ql_face_from_second_boolean_output_replays_in_place(): + with s.GraphSession(graph_id="second-profile") as session: + base = s.make_box_rsolid(10, 2, 2) + tool = s.make_box_rsolid(2, 4, 4, bottom_face_center=(0, 0, -1)) + pieces = s.boolean_rsolidlist(left=[base], right=[tool], operation="cut") + profile = s.ql.faces().where(s.ql.prop("geom.normal.z", ">", .9)).exactly(1).resolve(pieces[1])[0] + body = s.extrude_taper_rsolid(profile=profile, vector=(0, 0, 1), taper=5) + session.capture_result(value=body) + replayed = s.replay_model_json(s.export_model_json(session=session), strict=True)[0] + from simplecadapi.kernel.ocp_properties import center_of_mass + assert tuple(center_of_mass(replayed.wrapped)) == pytest.approx(tuple(center_of_mass(body.wrapped))) diff --git a/test/test_serialization.py b/test/test_serialization.py index 880d4269..ccb5be6a 100644 --- a/test/test_serialization.py +++ b/test/test_serialization.py @@ -357,6 +357,14 @@ def test_canonical_core_op_set_is_exact_contract(self): "make_twisted_sweep_rsolid", "make_translate_rshape", "make_rotate_rshape", + "make_scale_rsolid", + "make_transform_rsolid", + "make_offset_rsolid", + "make_extrude_taper_rsolid", + "make_sweep_multisection_rsolid", + "make_extrude_until_rsolid", + "make_draft_rsolid", + "make_boolean_rsolidlist", "make_mirror_rshape", "make_cut_rsolid", "make_union_rsolid", diff --git a/test/test_sketch_closed_bspline.py b/test/test_sketch_closed_bspline.py new file mode 100644 index 00000000..cacb7d73 --- /dev/null +++ b/test/test_sketch_closed_bspline.py @@ -0,0 +1,58 @@ +"""Closed spline seams are topology endpoints, including periodic NURBS.""" +import math +import pytest +import simplecadapi as scad +from OCP.BRepGProp import BRepGProp +from OCP.GProp import GProp_GProps + + +def accurate_mass(shape, *, volume=False): + props = GProp_GProps() + if volume: + BRepGProp.VolumePropertiesGK_s(shape.wrapped, props, 1e-10, True, True) + else: + BRepGProp.SurfaceProperties_s(shape.wrapped, props, 1e-10) + return props.Mass() + + +def rational_circle(): + poles = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1), (1, 0)] + weights = [1, math.sqrt(.5), 1, math.sqrt(.5), 1, math.sqrt(.5), 1, math.sqrt(.5), 1] + return poles, weights + + +def test_closed_rational_bspline_same_endpoint_promotes_exact_face(): + poles, weights = rational_circle() + sketch = scad.make_sketch_rsketch(name='closed-rational') + sketch = scad.add_point_rsketch(sketch, 'seam', 1, 0) + sketch = scad.add_bspline_rsketch(sketch, 'boundary', 'seam', 'seam', poles, + degree=2, knots=[0, .25, .5, .75, 1], multiplicities=[3, 2, 2, 2, 3], weights=weights) + face = scad.make_face_from_sketch_rface(sketch=sketch) + assert accurate_mass(face) == pytest.approx(math.pi, rel=1e-9) + with scad.GraphSession() as session: + sketch2 = scad.make_sketch_rsketch(name='replayed-closed-rational') + sketch2 = scad.add_point_rsketch(sketch2, 'seam', 1, 0) + sketch2 = scad.add_bspline_rsketch(sketch2, 'boundary', 'seam', 'seam', poles, + degree=2, knots=[0, .25, .5, .75, 1], multiplicities=[3, 2, 2, 2, 3], weights=weights) + face2 = scad.make_face_from_sketch_rface(sketch=sketch2) + solid = scad.extrude_rsolid(face2, (0, 0, 1), 2) + session.capture_result(value=solid) + from simplecadapi.recording.serializer import replay_graph + rebuilt = replay_graph(session.graph) + assert accurate_mass(rebuilt[0], volume=True) == pytest.approx(math.pi * 2, rel=1e-9) + + +def test_periodic_bspline_seam_does_not_replace_control_poles(): + poles = [(2, 0), (0, 2), (-2, 0), (0, -2)] + # The seam lies midway between poles for this periodic quadratic basis. + native = scad.make_spline_redge(control_points=[(x, y, 0) for x, y in poles], degree=2, periodic=True) + from OCP.BRepAdaptor import BRepAdaptor_Curve + adaptor = BRepAdaptor_Curve(native.wrapped) + seam = adaptor.Value(adaptor.FirstParameter()) + wire = scad.make_wire_from_edges_rwire([native]) + reference = scad.make_face_from_wire_rface(wire) + sketch = scad.make_sketch_rsketch(name='periodic') + sketch = scad.add_point_rsketch(sketch, 'seam', seam.X(), seam.Y()) + sketch = scad.add_bspline_rsketch(sketch, 'boundary', 'seam', 'seam', poles, degree=2, periodic=True) + face = scad.make_face_from_sketch_rface(sketch=sketch) + assert face.get_area() == pytest.approx(reference.get_area(), rel=1e-9) diff --git a/test/test_surface_api.py b/test/test_surface_api.py index 8ba9842e..4a7fddd2 100644 --- a/test/test_surface_api.py +++ b/test/test_surface_api.py @@ -431,7 +431,9 @@ def point_on(face, u, v): solid = scad.make_solid_from_shell_rsolid(shell) self.assertIsInstance(solid, scad.Solid) - self.assertAlmostEqual(solid.get_volume(), 512019.199, delta=2.0) + # The sewn solid is an 80 mm cube; the knot-span volume integral is exact + # (the fixed-order one overshot it by ~19 mm3 on these rational patches). + self.assertAlmostEqual(solid.get_volume(), 80.0**3, delta=0.1) self.assertTrue(all(face.get_area() > 4 * side * side for face in solid._iter_faces())) def test_trim_surface_with_hole_and_replay(self): diff --git a/tools/research/build123dftc/API_RESEARCH.md b/tools/research/build123dftc/API_RESEARCH.md new file mode 100644 index 00000000..1e635d55 --- /dev/null +++ b/tools/research/build123dftc/API_RESEARCH.md @@ -0,0 +1,124 @@ +# build123d 0.13 API 与测试集调研 + +本调研针对工作区 `.venv` 中实际安装的 build123d 0.13.0，以及上层 `tests/manifest.json` 固定的 `v0.13.0`、提交 `38effd343e1508964673faf59300a5cc68fbedc1`。2026 年 10 月 7 日已联网核查对应版本的官方文档。清单是测试范围和实现检查表，不能当作已通过转换的声明。 + +## 完整公开入口清单 + +`api_coverage.json` 从实际安装包生成，包含以下范围： + +| 范围 | 数量 | 含义 | +| --- | ---: | --- | +| 包 `__all__` 导出 | 203 | 官方顶层公开入口 | +| 公开成员定义 | 540 | 按定义所属类去重，含可达继承方法、属性与建模运算符 | +| 类接口 | 138 | 导出类，加上 Shape、几何维度 mixin、Builder、BaseObjectMeta | +| 工作区模型 | 50 | manifest 中全部模型，逐项记录调用位置统计 | +| 模型使用的顶层调用 | 50 种 | 已排除 `__main__` 导出代码和恒为 False 的文档生成分支 | +| 顶层调用位置 | 454 | 源码静态位置数量，循环次数和运行时内部调用未展开 | + +顶层入口分类：32 个枚举，15 个常量或类型别名，3 个 builder，4 个位置阵列上下文，27 个曲线对象入口、15 个草图对象入口、11 个实体对象入口（均包含 Base 类），6 个图纸对象入口，23 个建模操作，12 个几何类入口，20 个直接拓扑入口，5 个装配关节，9 个导出入口，6 个导入入口，以及 15 个其他工具入口。 + +成员分类：40 个 `make_*` 等工厂、68 个直接特征方法、18 个变换方法、41 个代数运算符定义、4 个上下文生命周期方法、122 个属性，以及 247 个查询或工具方法。分类采用方法名和所属模块，不能替代逐方法的行为测试。底层 OCP/Python 标准类型的成员和下划线内部实现不算公开 API；专门列入了建模运算符。 + +重新生成： + +```bash +.venv/bin/python simplecadapi/tools/research/build123dftc/research/inspect_api.py \ + --manifest tests/manifest.json \ + --output simplecadapi/tools/research/build123dftc/api_coverage.json +``` + +清单内每条入口有签名、定义文件与行号，类接口指向去重后的成员定义。`conversion_status: unverified` 表示尚未通过该接口的转换验证。后续覆盖报告应区分“识别入口”“真正生成 SimpleCAD 特征”“几何验证通过”，不要把成功执行源脚本等同于转换成功。 + +生成器也接受 `--validation-report` 和 `--traces-dir`。指定严格验收报告后，`verified_sampled_usage` 仅表示列出的模型中执行过该入口且模型验收通过。矩阵保留模型名单与报告 SHA256；其他参数、模式和未执行分支仍未验证。方法证据使用 trace 的实际 `source`，不会仅凭同名方法就把整个继承接口标为通过。最终验收报告更新后需重新生成矩阵。 + +## 捕获结构与可行的扩展方案 + +builder 与 algebra 是建模方式，Direct API 是两者共用的拓扑层；顶层入口捕获和底层特征捕获可以互补。[官方 Direct API 说明](https://build123d.readthedocs.io/en/v0.13.0/direct_api_reference.html) + +当前实现选择 Direct API 层记录实体构造图，并在实体特征的输入边界转录草图轮廓。这覆盖两种建模方式，不需要改变 builder 的 Python frame。下文第一层是未来扩展原始对象/草图操作记录的方案，不是当前已实现的声明。`project / offset / make_hull` 等草图变化目前进入求解后的精确轮廓；不会逐项保留原草图操作。非平面 Face/Shell 曲面工厂、Vertex 终点放样以及清单中其他未验证 API 仍需单独检查，未支持构造必须显式报告。 + +### 第一层：可读的原建模操作 + +安装源码中 `build_common.BaseObjectMeta.__call__` 是全部内置 `BaseObject` 子类的统一入口。它能保留 `Box`、`Circle`、`Spline`、`Hole` 等原参数，也能接收自定义继承类；外层调用期间，内部建模需要防止被重复计入。23 个公开 operations 应全部登记。记录原参数以后，应展开 locations、默认参数以及隐式 pending faces/edges。 + +### 第二层：Direct API 特征与几何 + +工厂需要覆盖以下定义；方法会被继承，不能只包装 `Solid` 一种类： + +- `Edge.make_bezier / make_circle / make_constrained_arcs / make_constrained_lines / make_ellipse / make_parabola / make_hyperbola / make_helix / make_line / make_mid_way / make_spline / make_bspline / make_spline_approx / make_tangent_arc / make_three_point_arc`。 +- `Wire.make_circle / make_convex_hull / make_ellipse / make_polygon / make_rect`。 +- `Face.make_bezier_surface / make_gordon_surface / make_rect / make_surface / make_surface_from_array_of_points / make_surface_from_curves / make_surface_patch / make_holes`。 +- `Shell.make_loft`。 +- `Solid.make_box / make_cone / make_cylinder / make_loft / make_sphere / make_torus / make_wedge`。 +- `Compound.make_text / make_triad`。 +- `Shape / Mixin1D / Mixin2D / Mixin3D / Edge / Wire / Face / Shell / Solid / Compound` 各自声明的 `extrude`；其中部分重载返回不同维度，不能假定都是 Solid。 +- 3D 的 `extrude_taper / extrude_until / extrude_linear_with_rotation / revolve / sweep / sweep_multi / thicken / draft / fillet / chamfer / hollow / offset_3d / dprism`。 +- 2D/1D 的 `offset / offset_2d / fillet_2d / chamfer_2d / trim* / project* / split* / close / stitch / combine / wrap*`。 + +对于没有 SimpleCAD 同名原语的曲线构造（如受约束圆弧、Airfoil、BlendCurve），可把求解后的单条曲线分解为解析参数或精确 BSpline 定义，再以 SimpleCAD 曲线原语重建。需保留 poles、degree、weights、knots、multiplicities、periodic，以及区间/方向。这个方法保留草图和后续特征，而不是把最终实体导入当作转换。 + +### 第三层：组合、位置与查询 + +布尔定义分布在 `Shape`、`Compound` 与 `Mixin1D`。1D 的加法可能得到 Wire/Curve，不能按 3D union 发射。`Shape` 的 `fuse / cut / intersect` 是 builder 和 algebra 实际共用的接口，应按几何维度分派。 + +`Location.__mul__` 对 Shape 实际调用 `other.moved(self)`，`Plane.__mul__` 也进入位置变换。因此包装 `Shape.moved` 后已经能捕获大多数 algebra placement 和 builder 发布，不必再重复包装 `*`。`move / locate / location.setter` 是原位变更；`moved / located` 返回副本。原位变更应建立新节点，保留变更前的输入节点。`translate / rotate / scale / mirror / transformed / transform_shape / transform_geometry` 也需覆盖。 + +查询 API 大多数不用发射新的 FTC 操作，但查询结果必须用于源脚本继续执行。边/面选择器的结果应关联已有特征，再记录指纹或索引；不能把选中边的 repr 当作可重放参数。曲线的 `@ / % / ^` 分别参与求值和位置计算，记录最终 Vector/Location 参数即可。枚举、单位、字体和颜色也应有稳定的序列化。 + +## 0.13 builder 语义的两个关键陷阱 + +所有 builder 先在自身 XY 局部坐标中构造。`output_placements` 只在输出或退出后统一应用。对象构造时使用的 `Locations` 属于局部位置；builder 发布时另有外层 `publication_locations`。两种位置不能重复应用，尤其是嵌套 BuildPart、BuildSketch、BuildLine 和多个 face placement。[官方 builder 位置说明](https://build123d.readthedocs.io/en/v0.13.0/key_concepts_builder.html) + +本地源码 `Builder.__enter__` 用 Python frame 判断当前 builder 与父 builder 是否同一作用域。直接加 `__enter__` 或 `__init__` 包装函数会改变 frame，可能把嵌套 builder 误判为无父级。优先捕获 `_add_to_context`、`_PublicationService.place/publish`；如必须包装 enter/init，要保持原同作用域判定的含义，并测试函数内返回私有草图这种有意隔离的情况。 + +`Builder._add_to_context` 中拿到的 shapes 是 builder 的局部坐标，不能称为全局坐标。此处同时维护累计几何、pending faces/edges 和 Select.LAST/NEW 的变化历史。对截面依赖引用、用于扫掠的独立路径、多个离散实体，需要保留输入依赖图。 + +## 50 个模型真正考验的能力 + +最常出现的静态调用：BuildSketch 57，BuildPart 55，extrude 40，Circle 29，Rectangle 25，Locations 23，Box/Line 各 18，BuildLine 16，fillet 15，RegularPolygon 14，GridLocations 11，Plane 10。完整逐模型统计见 JSON。 + +以下模型需要独立回归，避免简单盒子通过造成覆盖错觉： + +| 模型 | 关键行为 | +| --- | --- | +| 09、10、11、18、29、45、46、47 | 边/面选择、3D 圆角与倒角、修改后的选择指纹 | +| 12、30、40、46、47 | 样条、Bezier、端点切向量、非直线轮廓及扫掠 | +| 13、41、49 | 普通孔、沉孔、锥孔、负向深度、自动贯穿深度、多位置 | +| 14、39、40、46、50 | pending 路径/截面、扫掠参数、曲线起点坐标系 | +| 16、17、20、21、22、24、27、37、38、43 | 不同 workplane、嵌套位置、旋转、偏移与 builder 发布 | +| 19、31、32、33、42、48 | 循环/函数生成阵列，以及源查询决定下一操作参数 | +| 23、29、44、46、47 | 旋转、放样、壁厚偏置、开口选择、多截面 | +| 34 | Text 的字体形状与字内孔，不能只重建外轮廓 | +| 36 | `extrude(until=Until.*)`，限界对象与方向 | +| 45 | section、面内孔与比例缩放 | +| 49 | 四个彼此独立的 BuildPart 输出组合为 Compound | +| 50 | 完全 algebra 模型：Helix、`path ^ 0`、位置相乘、显式 sweep 参数 | + +源码中被禁用的 SVG 文档导出和 `__main__` STEP 输出不属于建模转换测试，但导入/导出公开入口仍列在 API 清单。清单中的矩阵、关节、图纸类和未被这 50 个模型使用的几何操作，应通过额外小型行为用例逐项验证；50 个模型不等于全部 API 覆盖。 + +## SimpleCAD 对应关系与几何验证 + +现有目标原语已提供：线/圆/椭圆/三点圆弧/角度圆弧/精确样条/插值样条/螺旋、wire/face 构造、草图 2D 布尔、3D 原语、3D 布尔、拉伸/旋转/放样/扫掠、圆角/倒角/抽壳，以及曲面构造。可优先复用 `operators/geometry.py`、`features.py`、`boolean.py`、`transform.py` 和 cqftc 的选择指纹与重放模式。 + +每个测试应同时检查操作结构与几何：FTC 内必须存在实际构造特征和输入依赖，执行生成脚本时不依赖 build123d；体积、包围盒、实体数量和有效性应该与源模型一致。只有体积相同无法证明孔位置和姿态正确，建议再比较差集体积或对称差集，并在拓扑变化时用几何指纹选择。基准来源是执行源脚本所得结果或 manifest 的 STEP，不能把待检 FTC 的结果本身作为基准。 + +验收工具已实现独立进程与超时隔离，缺少指标、源执行失败、空 BODIES、无效实体、转换元数据中的 unsupported/unknown 都会拒绝。包围盒比较六个世界坐标而非仅比较尺寸。体积与 STEP 差集使用 `VolumePropertiesGK_s(..., Eps=1e-9, OnlyClosed=True, IsUseSpan=True)`；有理 BSpline 使用默认积分或普通自适应积分可能产生明显误差，所以源与目标必须用同一定义。 + +模型 28 揭示了内核差异：OCP 7.9 对实际形状与基准 STEP 的共同内部点判为 IN，却把 Common 计算为空、双向 Cut 留下全部体积。标准 ShapeFix 和微小 fuzzy 未解决。实际形状重新导出 STEP 后，独立 OCP 8.0.1.1 求得 Common 等于完整体积、双向 Cut 都为空。可选 `--reference-python` 因此让 FTC 在 SimpleCAD 环境中构建，同时在指定独立内核进程中对 STEP 做差集。实际 STEP 的读回体积、包围盒、有效性与实体数量也必须与 FTC 真实 BODIES 一致，验收门槛不变，报告记录两个内核与积分方法。 + +面积计算在独立的几何深拷贝上先按 C1 连续性切分积分区间，再用明确 `Eps` keyword 的自适应积分；不修改实际 FTC 或 STEP。半径 1、高度 1 的精确有理 BSpline 圆柱有面积 `4π`、体积 `π` 的独立数学测试。OCP 7.9 的测量区间切分在该例有约 `7.7e-9` 相对误差，数学测试精度为 `1e-8`，整模型验收门槛保持原值。 + +参考 STEP 的临时实际导出使用 trace `source_metadata.export_options` 中声明的参数曲线与精度模式；没有声明时用标准 `True / AVERAGE`。差集布尔在首次 Build 前统一使用输入实际 BRep 顶点/边容差与内核 `Precision.Confusion` 的最大值，记录该值，不逐级尝试容差。差集必须有效并通过原体积门槛。模型 46 的当前记录表明即使匹配 `False / GREATEST` 并使用该固定规则，跨内核差集仍可能无效；这种情况会报告 `reference_error`，不会将基础指标通过冒充严格 STEP 匹配通过。 + +验收 CLI 有任何 rejected/partial 或没有可验收案例时返回退出码 1，所有案例 accepted 才返回 0；NaN、Inf 与非正 timeout 会作为参数错误拒绝，报告仍保存每例拒绝原因。 + +确实不能转换的入口应报出明确 API 名、源位置与原因。允许用户显式选择近似曲线时，应报告近似误差并保持后续特征可修改。最终 BRep/STEP 导入只能作为明确标记的外部几何来源，不能用它把未覆盖操作伪装成成功 FTC 转换。 + +## 官方核查来源 + +- [Objects](https://build123d.readthedocs.io/en/v0.13.0/objects.html) +- [Operations](https://build123d.readthedocs.io/en/v0.13.0/operations.html) +- [Builder concepts](https://build123d.readthedocs.io/en/v0.13.0/key_concepts_builder.html) +- [Algebra concepts](https://build123d.readthedocs.io/en/v0.13.0/key_concepts_algebra.html) +- [Direct API reference](https://build123d.readthedocs.io/en/v0.13.0/direct_api_reference.html) +- [固定测试集上游提交](https://github.com/gumyr/build123d/tree/38effd343e1508964673faf59300a5cc68fbedc1) diff --git a/tools/research/build123dftc/BENCHMARK.md b/tools/research/build123dftc/BENCHMARK.md new file mode 100644 index 00000000..c6a2be32 --- /dev/null +++ b/tools/research/build123dftc/BENCHMARK.md @@ -0,0 +1,59 @@ +# 工作区 50 个模型实测 + +日期：2026-10-07。输入为相邻工作区 `tests/manifest.json` 中的 50 个官方 +build123d 模型，版本 0.13.0，源内核 OCP 8.0.1.1；FTC 在 +SimpleCADAPI 2.2.0b1 / OCP 7.9.3.1 中构建，参考 STEP 在独立 OCP 8 环境对账。 +运行命令见 [README.md](README.md)。 + +| 检查 | 结果 | +| --- | --- | +| 源模型执行、特征图捕获 | 50 / 50，未识别实体操作 0 | +| FTC 源码生成 | 50 / 50，410 个特征，无未翻译记录 | +| FTC 实际构建、内核有效性、实体数量 | 50 / 50 | +| 体积、表面积、世界包围盒 | 50 / 50 | +| 加入参考 STEP 双向差集的严格验收 | 49 / 50 | + +所有模型的最大相对体积误差为 `1.492e-6`，最大面积误差为 `1.092e-6`， +最大包围盒误差（相对于对应轴跨度）为 `2.778e-9`。均远低于 `1e-3` 的 +验收阈值。原始报告在本机 `out/validate.json`，逐模型源码在 `out/ftc`， +输入特征图在 `out/traces`。这些运行产物被 Git 忽略。 + +模型 `46_tea_cup` 构建成功且全部基础几何检查通过，体积相对误差约 +`1.45e-9`、世界包围盒一致。独立参考内核的 STEP 双向差集计算仍生成无效 +拓扑，因此保留 `reference_error`，严格验收判为拒绝。没有跳过该模型、 +改变差集门槛或把无效差集当作零。报告同时给出 `metrics_quality=accepted` +与 `quality=rejected`，批量 CLI 在这次严格验收中返回 1。 + +测试按先写断言再实现的方式推进，相关回归包括真实捕获、格式、几何、未知 +API、孤立进程崩溃、超时、同体积/同包围盒但孔位不同的反例、图重放以及 +既有 CQ / WHUCAD、草图、QL 测试。295 项相关用例通过，另有 35 个子测试。 +六个真实图 fixture 保存在 `test/build123d_traces`，普通 CI 不需要 build123d。 + +203 个顶层导出、540 个去重公开成员的清单与样例证据在 `api_coverage.json`。 +标为 `verified_sampled_usage` 的条目仅说明相应已验收样例使用过该 API， +不代表其全部参数组合或全部公开 API 都已通过转换。复杂曲面构造等未接入 +边界在 [API_RESEARCH.md](API_RESEARCH.md) 和转换 meta 中明确列出。 + +## 2026-10-13 审查修复与新增 41 个模型 + +修复 1 项 P1 和 9 项 P2，涵盖空输出识别、实际 build 返回值验收、多实体 +布尔及圆角、Face 截面孔、空侧分割、QL 输入录制和多输出槽重放。 +圆环的主圆周角度被保留，非完整管截面明确标为未转换。 + +| 检查 | 原有 50 个 | 新增 41 个 | +| --- | --- | --- | +| 源模型捕获 | 50 / 50 | 40 / 41 | +| 完整 FTC 生成 | 50 / 50 | 31 / 41 | +| 基础几何验收 | 50 / 50 | 21 / 41 | +| 参考 STEP 严格对账 | 49 / 50 | 21 / 41 | + +原有 50 个仅剩模型 46 的既有参考内核错误。新增模型 80 在 180 秒捕获 +上限内未完成；其他未通过项包括未录制的曲面/实体构造、草图与扫掠构建 +失败、选择失败、实际返回模型与 BODIES 不一致、几何差异及参考内核错误。 +未放宽验收阈值，未跳过失败模型。 + +最终相关回归 247 项通过，另有 137 个子测试。全仓库运行中的 3 项剩余失败 +在未修改的 HEAD 副本中复现，分别涉及圆角诊断、FreeCAD 关节计数和 Gordon +曲面体积断言。逐模型结果、生成代码和失败说明保存在相邻工作区 +`artifacts/build123dftc/REVIEW_RESULTS.md`；两批原始 JSON 分别在 +`review_fixed/validate.json` 和 `additional_review_fixed/validate.json`。 diff --git a/tools/research/build123dftc/README.md b/tools/research/build123dftc/README.md new file mode 100644 index 00000000..51ffb8c5 --- /dev/null +++ b/tools/research/build123dftc/README.md @@ -0,0 +1,164 @@ +# build123d → FTC 转换工具 + +把真实执行的 build123d 模型转换成本仓库现行 FTC Python：显式草图、实体 +特征、布尔和 QL 修改选择。组织方式沿用 `tools/research/cadqueryftc`，转换 +与验收分开。支持 Builder、代数写法及已接入的底层实体 API。 + +```text +trusted model.py → build123d_trace.py → trace.json +trace.json → build123d_to_ftc.py → ftc.py + meta.json + sketches.json +ftc.py + trace.json [+ reference STEP] → build123d_validate.py → validate.json +trace.json → build123d_profile.py → profile.json +``` + +捕获执行模型的 Python；只对可信源文件运行。模型的 `__main__` 分支不会运行， +可在顶层将最终形状绑定为 `result`。显式输出即使为空也具有优先级，不会回退 +到先前创建的实体。捕获和验收分别在隔离子进程执行，设置 +超时，一例失败仍处理后续文件。 + +## 环境 + +本次实测为 Python 3.12、build123d 0.13.0 / OCP 8.0.1.1，以及 +SimpleCADAPI 2.2.0b1 / OCP 7.9.3.1。两个内核的绑定不能混装在同一环境： + +```bash +# 在 SimpleCADAPI 仓库根目录运行。环境放在相邻工作区。 +uv venv ../.venv --python 3.12 +uv pip install --python ../.venv/bin/python 'build123d==0.13.0' +uv venv ../.venv-sca --python 3.12 +uv pip install --python ../.venv-sca/bin/python -e . 'cadquery-ocp==7.9.3.1' pytest +``` + +已有环境无需重建。翻译阶段是纯 Python，不导入 build123d 或 CAD 内核；启用 +约束恢复时才加载现有 CQ 的求解器。 + +## 单模型 + +```bash +../.venv/bin/python tools/research/build123dftc/build123d_trace.py \ + --input ../tests/models/01_rectangular_plate.py \ + --out tools/research/build123dftc/out/traces + +../.venv-sca/bin/python tools/research/build123dftc/build123d_to_ftc.py \ + --trace tools/research/build123dftc/out/traces/01_rectangular_plate.trace.json \ + --out tools/research/build123dftc/out/ftc + +../.venv-sca/bin/python tools/research/build123dftc/build123d_validate.py \ + --ftc-dir tools/research/build123dftc/out/ftc \ + --traces-dir tools/research/build123dftc/out/traces \ + --report tools/research/build123dftc/out/validate.json +``` + +`--constraints on` 从实际草图恢复推断约束，复用 `cqftc.constraints`。只有生产 +求解器确认坐标复现才插入约束；约束 ID 标记推断出处。椭圆、样条及耗时超限 +的草图在 `constraint_recovery` 中明确记录状态，其精确几何仍保留。 + +## 工作区 50 个模型 + +```bash +../.venv/bin/python tools/research/build123dftc/build123d_trace.py \ + --manifest ../tests/manifest.json \ + --out tools/research/build123dftc/out/traces --timeout 180 + +../.venv-sca/bin/python tools/research/build123dftc/build123d_to_ftc.py \ + --traces-dir tools/research/build123dftc/out/traces \ + --out tools/research/build123dftc/out/ftc + +../.venv-sca/bin/python tools/research/build123dftc/build123d_validate.py \ + --ftc-dir tools/research/build123dftc/out/ftc \ + --traces-dir tools/research/build123dftc/out/traces \ + --reference-step-dir ../tests/step --reference-python ../.venv/bin/python \ + --report tools/research/build123dftc/out/validate.json --timeout 180 + +../.venv-sca/bin/python tools/research/build123dftc/build123d_profile.py \ + --traces-dir tools/research/build123dftc/out/traces \ + --report tools/research/build123dftc/out/profile.json +``` + +也可用 `--inputs-dir` 处理目录中的 `.py` 文件，或用 `--input` 指定一个模型。 +每个模型产生 `.trace.json`、执行日志、`.ftc.py`、`.meta.json` 和 +`.sketches.json`。批量验收报告保留所有模型，缺少转换结果也计入失败。 + +## 验收依据 + +- 实际执行 FTC，以 `build()` 返回的 Solid、Part 或 Assembly 为验收对象， + 应用嵌套装配位置后检查非空实体、内核有效性、体积、表面积和实体数量。 + `BODIES` 必须非空，并与实际返回模型的实体数量和几何一致。 +- 比较世界坐标中的六个包围盒边界；同尺寸但位置错误会失败。 +- 指定参考 STEP 时，要求两个方向几何差集的总体积通过检查。 +- `--reference-python` 让参考几何对账在指定内核执行，FTC 仍在 + SimpleCADAPI 环境构建。报告记录两个内核版本，并检查 STEP 导出往返的 + 体积、包围盒、有效性和实体数。 +- 体积使用按样条节点区间计算的 Gauss–Kronrod 积分。普通固定阶积分对有理 + 样条有明显误差，还会在某些非均匀缩放后的裁剪曲面上崩溃。 + +面积只在独立副本上切开不连续的曲面参数区间，再做自适应积分；原始模型和 +拓扑保持不变。参考导出沿用 manifest 声明的参数曲线与精度选项，布尔对账 +采用输入已有的内核容差，报告保留这些设置。 + +阈值为体积、面积和包围盒相对误差 `1e-3`，另有绝对误差保护；STEP 双向 +差集体积相对误差 `1e-3`。源执行失败、缺指标、未知操作、翻译不完整和空实体 +都不会判为通过。验收通过是给定输入在这些阈值下的结果。`metrics_quality` +单独报告基础几何检查；要求 STEP 对账时，任何参考计算失败仍会使 +`quality` 为拒绝，且 CLI 返回非零。工作区实测结果见 [BENCHMARK.md](BENCHMARK.md)。 + +模型 28 的重合球面在 OCP 7.9 中出现错误的空交集；相同几何在 OCP 8 的 +严格双向差集为零。因此上述工作区命令使用独立的 OCP 8 参考环境。 + +## 转换结构和覆盖 + +`b3ftc/tracer.py` 在真实底层实体构造、布尔、修改和变换边界捕获操作图。 +所有已执行的草图对象与查询仍由 build123d 计算，在实体特征的输入处转录 +实际轮廓。JSON 保存参数、世界坐标、精确曲线控制数据和拓扑指纹，不保存 +最终实体 BRep。`profiles.py`、`emit.py`、`replay.py` 分别负责轮廓、格式和 +实体数据流；外部验收位于 `validation.py` 及独立 worker。 + +当前支持盒、圆柱、圆锥、球、完整圆环及部分原语；拉伸、带拔模角拉伸、 +限界拉伸、扭转拉伸、旋转、放样、单/多截面扫掠；布尔、圆角、倒角、拔模、 +双向实体偏移与抽壳、平面分割、刚体与一般仿射变换、多实体组合。 +草图支持直线、圆弧、圆、椭圆、精确有理 B 样条与闭合/周期样条；曲线型 +文字及三维路径使用实际曲线控制数据。多实体输出为完整 `@scad.assemble`。 + +切割与交集使用录制的 `scad.boolean_rsolidlist` 保留全部输出实体；Compound +成员属于同一交集操作数，多参数交集仍按顺序取交。每块实体的圆角/倒角使用 +各自的选边基数，未选中的实体直接保留。多输出顺序通过实体几何指纹恢复； +截面特征保存有序输入引用及输出槽，QL 得到的截面也进入录制图。 +实体排序使用世界包围盒和体积，避免不同 OCCT 版本质心计算的差异。 +圆环支持 `major_angle` 主圆周角度；非完整管截面的 `start_angle/end_angle` +目前明确记录为未转换，不会生成完整圆环代替。 +更新工具后应重新捕获旧模型；缺少逐实体选边信息的旧多实体圆角图会被标为 +未转换，历史空结果图也需要重捕获才能纠正。 + +生成代码使用现行 FTC 块头、几何档标注、keyword 实参、QL 谓词和基数。 +数字来源于实际调用，不虚构参数名。动态追踪只描述执行到的路径；输出不会 +保留未执行的分支，也不承诺恢复源草图的约束或全部表达式。 + +**API 清单不等于全部 API 转换已通过验证。** `api_coverage.json` 和 +`API_RESEARCH.md` 梳理了 203 个顶层导出、540 个去重公开成员和 138 个类。 +查询、布局和多数草图 API 通过实际求值再转录轮廓覆盖；非平面曲面构造、 +原生内核直接包装等未接入的实体构造、部分圆环截面、特殊扫掠模式、复杂孔 +拓扑变化等仍有明确边界。未知节点会阻断依赖它的后续特征，并写入 meta， +不会导入最终模型作为替代。完整清单可重生： + +```bash +../.venv/bin/python tools/research/build123dftc/research/inspect_api.py --help +``` + +## 回归测试 + +`test/build123d_traces` 保留真实捕获的轮廓、修改、镜像、文字和螺旋扫掠 +fixture，并带出处。普通 FTC 测试不依赖 build123d；执行捕获测试在其专用 +环境运行。 + +```bash +../.venv/bin/python -m pytest test/test_build123d_trace.py test/test_build123d_unknown_api.py -q +../.venv-sca/bin/python -m pytest \ + test/test_build123d_cli.py test/test_build123d_translation_output.py \ + test/test_build123d_validation.py test/test_deformation_features.py \ + test/test_section_features.py test/test_limited_extrusion.py \ + test/test_rational_volume_precision.py test/test_sketch_closed_bspline.py -q +``` + +`test/test_build123d_review_regressions.py` 额外从专用 build123d 环境捕获审查 +反例，再在 SimpleCADAPI 环境执行生成代码并验收实际返回模型；运行该文件 +需要相邻的 `../.venv`。 diff --git a/tools/research/build123dftc/api_coverage.json b/tools/research/build123dftc/api_coverage.json new file mode 100644 index 00000000..15ecbe82 --- /dev/null +++ b/tools/research/build123dftc/api_coverage.json @@ -0,0 +1,19803 @@ +{ + "schema_version": 1, + "purpose": "Version-specific API inventory and static source corpus evidence; unverified is not implemented support.", + "build123d_version": "0.13.0", + "corpus_tag": "v0.13.0", + "corpus_commit": "38effd343e1508964673faf59300a5cc68fbedc1", + "sources": [ + "https://build123d.readthedocs.io/en/v0.13.0/objects.html", + "https://build123d.readthedocs.io/en/v0.13.0/operations.html", + "https://build123d.readthedocs.io/en/v0.13.0/key_concepts_builder.html", + "https://build123d.readthedocs.io/en/v0.13.0/key_concepts_algebra.html", + "https://build123d.readthedocs.io/en/v0.13.0/direct_api_reference.html" + ], + "scope": "203 package __all__ exports plus public build123d-declared members reachable through these classes, Shape, topology mixins and Builder; Python/OCP internals are excluded.", + "counts": { + "top_level_exports": 203, + "unique_public_member_declarations": 540, + "class_interfaces": 138, + "corpus_models": 50, + "corpus_distinct_top_level_calls": 50, + "corpus_top_level_call_sites": 454, + "top_level_by_category": { + "constant_or_type_alias": 15, + "enum": 32, + "locations": 4, + "builder": 3, + "object_curve": 27, + "drawing_object": 6, + "object_sketch": 15, + "object_part": 11, + "geometry": 12, + "direct_topology": 20, + "assembly_joint": 5, + "utility": 15, + "export": 9, + "import": 6, + "operation": 23 + }, + "members_by_category": { + "algebra_operator": 41, + "property": 122, + "query_or_utility": 247, + "feature": 68, + "transform": 18, + "factory": 40, + "context_lifecycle": 4 + } + }, + "top_level_api": [ + { + "name": "MC", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "MM", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "CM", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "M", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "IN", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "FT", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "THOU", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "UNITS_PER_METER", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "G", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "KG", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "G_PER_LB", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "LB", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "UNITS_PER_KILOGRAM", + "kind": "value", + "category": "constant_or_type_alias", + "module": "builtins", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Align", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 55, + "signature": "(*values)", + "values": [ + "MIN", + "CENTER", + "MAX", + "NONE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ApproxOption", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 72, + "signature": "(*values)", + "values": [ + "ARC", + "NONE", + "SPLINE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "AngularDirection", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 83, + "signature": "(*values)", + "values": [ + "CLOCKWISE", + "COUNTER_CLOCKWISE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "CenterOf", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 93, + "signature": "(*values)", + "values": [ + "GEOMETRY", + "MASS", + "BOUNDING_BOX" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ContinuityLevel", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 104, + "signature": "(*values)", + "values": [ + "C0", + "C1", + "C2" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Convexity", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 126, + "signature": "(*values)", + "values": [ + "CONVEX", + "CONCAVE", + "SMOOTH", + "SADDLE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Extrinsic", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 150, + "signature": "(*values)", + "values": [ + "XYZ", + "XZY", + "YZX", + "YXZ", + "ZXY", + "ZYX", + "XYX", + "XZX", + "YZY", + "YXY", + "ZXZ", + "ZYZ" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "FontStyle", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 275, + "signature": "(*values)", + "values": [ + "REGULAR", + "BOLD", + "ITALIC", + "BOLDITALIC" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "FrameMethod", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 171, + "signature": "(*values)", + "values": [ + "FRENET", + "CORRECTED" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "GeomType", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 181, + "signature": "(*values)", + "values": [ + "PLANE", + "CYLINDER", + "CONE", + "SPHERE", + "TORUS", + "BEZIER", + "BSPLINE", + "REVOLUTION", + "EXTRUSION", + "OFFSET", + "LINE", + "CIRCLE", + "ELLIPSE", + "HYPERBOLA", + "PARABOLA", + "OTHER" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "HeadType", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 205, + "signature": "(*values)", + "values": [ + "STRAIGHT", + "CURVED", + "FILLETED" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Intrinsic", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 216, + "signature": "(*values)", + "values": [ + "XYZ", + "XZY", + "YZX", + "YXZ", + "ZXY", + "ZYX", + "XYX", + "XZX", + "YZY", + "YXY", + "ZXZ", + "ZYZ" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Keep", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 237, + "signature": "(*values)", + "values": [ + "ALL", + "BOTTOM", + "BOTH", + "INSIDE", + "OUTSIDE", + "TOP" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Kind", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 251, + "signature": "(*values)", + "values": [ + "ARC", + "INTERSECTION", + "TANGENT" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Sagitta", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 287, + "signature": "(*values)", + "values": [ + "SHORT", + "LONG", + "BOTH" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "LengthMode", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 298, + "signature": "(*values)", + "values": [ + "DIAGONAL", + "HORIZONTAL", + "VERTICAL" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "MeshType", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 309, + "signature": "(*values)", + "values": [ + "OTHER", + "MODEL", + "SUPPORT", + "SOLIDSUPPORT" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Mode", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 262, + "signature": "(*values)", + "values": [ + "ADD", + "SUBTRACT", + "INTERSECT", + "REPLACE", + "PRIVATE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "NumberDisplay", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 321, + "signature": "(*values)", + "values": [ + "DECIMAL", + "FRACTION" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "PageSize", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 331, + "signature": "(*values)", + "values": [ + "A0", + "A1", + "A2", + "A3", + "A4", + "A5", + "A6", + "A7", + "A8", + "A9", + "A10", + "LETTER", + "LEGAL", + "LEDGER" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Tangency", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 353, + "signature": "(*values)", + "values": [ + "UNQUALIFIED", + "ENCLOSING", + "ENCLOSED", + "OUTSIDE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "PositionMode", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 365, + "signature": "(*values)", + "values": [ + "LENGTH", + "PARAMETER" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "PrecisionMode", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 375, + "signature": "(*values)", + "values": [ + "SESSION", + "GREATEST", + "AVERAGE", + "LEAST" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Select", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 394, + "signature": "(*values)", + "values": [ + "ALL", + "LAST", + "NEW" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Side", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 414, + "signature": "(*values)", + "values": [ + "LEFT", + "RIGHT", + "BOTH" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "SortBy", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 425, + "signature": "(*values)", + "values": [ + "LENGTH", + "RADIUS", + "AREA", + "VOLUME", + "DISTANCE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "TextAlign", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 438, + "signature": "(*values)", + "values": [ + "BOTTOM", + "CENTER", + "LEFT", + "RIGHT", + "TOP", + "TOPFIRSTLINE" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Transition", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 452, + "signature": "(*values)", + "values": [ + "RIGHT", + "ROUND", + "TRANSFORMED" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Unit", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 463, + "signature": "(*values)", + "values": [ + "MC", + "MM", + "CM", + "M", + "IN", + "FT", + "G", + "KG", + "LB" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Until", + "kind": "class", + "category": "enum", + "module": "build123d.build_enums", + "conversion_status": "unverified", + "source_file": "build123d/build_enums.py", + "source_line": 480, + "signature": "(*values)", + "values": [ + "NEXT", + "LAST", + "PREVIOUS", + "FIRST" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "HexLocations", + "kind": "class", + "category": "locations", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 989, + "signature": "(radius: 'float', x_count: 'int', y_count: 'int', major_radius: 'bool' = False, align: 'Align | tuple[Align, Align]' = (, ))", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "PolarLocations", + "kind": "class", + "category": "locations", + "module": "build123d.build_common", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/build_common.py", + "source_line": 1093, + "signature": "(radius: 'float', count: 'int', start_angle: 'float' = 0.0, angular_range: 'float' = 360.0, rotate: 'bool' = True, endpoint: 'bool' = False)", + "validation_evidence": { + "accepted_models": [ + "13_countersink_counterbore", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Locations", + "kind": "class", + "category": "locations", + "module": "build123d.build_common", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/build_common.py", + "source_line": 1148, + "signature": "(*pts: 'VectorLike | Vertex | Location | Face | Plane | Axis | Iterable[VectorLike | Vertex | Location | Face | Plane | Axis]')", + "validation_evidence": { + "accepted_models": [ + "05_offset_cutouts", + "06_point_list_holes", + "07_polygon_holes", + "13_countersink_counterbore", + "19_vertex_cutouts", + "23_revolved_profile", + "28_face_located_sphere_holes", + "33_function_generated_pattern", + "36_extrude_until", + "38_rotated_boxes", + "41_pillow_block", + "43_lego", + "45_key_cap", + "48_circuit_board", + "49_holes" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "GridLocations", + "kind": "class", + "category": "locations", + "module": "build123d.build_common", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/build_common.py", + "source_line": 1220, + "signature": "(x_spacing: 'float', y_spacing: 'float', x_count: 'int', y_count: 'int', align: 'Align | tuple[Align, Align]' = (, ))", + "validation_evidence": { + "accepted_models": [ + "11_grid_polygon_holes", + "16_mirrored_3d_parts", + "22_angled_drill_holes", + "31_nested_location_pattern", + "41_pillow_block", + "42_din_rail", + "43_lego", + "48_circuit_board" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BuildLine", + "kind": "class", + "category": "builder", + "module": "build123d.build_line", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/build_line.py", + "source_line": 39, + "signature": "(placement: 'Face | Plane | Location' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), mode: 'Mode' = )", + "validation_evidence": { + "accepted_models": [ + "04_lines_and_arcs_profile", + "08_i_beam", + "12_spline_profile", + "14_swept_square_tube", + "15_mirrored_profile", + "23_revolved_profile", + "29_occ_bottle", + "30_bezier_profile", + "35_curved_slots", + "39_pegboard_j_hook", + "40_handle", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BuildPart", + "kind": "class", + "category": "builder", + "module": "build123d.build_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/build_part.py", + "source_line": 42, + "signature": "(*placements: 'Face | Plane | Location', mode: 'Mode' = )", + "validation_evidence": { + "accepted_models": [ + "01_rectangular_plate", + "02_plate_with_hole", + "03_prismatic_solid", + "04_lines_and_arcs_profile", + "05_offset_cutouts", + "06_point_list_holes", + "07_polygon_holes", + "08_i_beam", + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "12_spline_profile", + "13_countersink_counterbore", + "14_swept_square_tube", + "15_mirrored_profile", + "16_mirrored_3d_parts", + "17_face_mirror", + "18_face_cutout", + "19_vertex_cutouts", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "23_revolved_profile", + "24_circle_rectangle_loft", + "25_offset_polygon_layers", + "26_thin_wall_box", + "27_split_plate", + "28_face_located_sphere_holes", + "29_occ_bottle", + "30_bezier_profile", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern", + "34_embossed_debossed_text", + "35_curved_slots", + "36_extrude_until", + "37_positioned_sketches", + "38_rotated_boxes", + "39_pegboard_j_hook", + "40_handle", + "41_pillow_block", + "42_din_rail", + "43_lego", + "44_loft", + "45_key_cap", + "47_vase", + "48_circuit_board", + "49_holes" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BuildSketch", + "kind": "class", + "category": "builder", + "module": "build123d.build_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/build_sketch.py", + "source_line": 39, + "signature": "(*placements: 'Face | Plane | Location', mode: 'Mode' = )", + "validation_evidence": { + "accepted_models": [ + "03_prismatic_solid", + "04_lines_and_arcs_profile", + "05_offset_cutouts", + "06_point_list_holes", + "07_polygon_holes", + "08_i_beam", + "11_grid_polygon_holes", + "12_spline_profile", + "14_swept_square_tube", + "15_mirrored_profile", + "16_mirrored_3d_parts", + "17_face_mirror", + "18_face_cutout", + "19_vertex_cutouts", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "23_revolved_profile", + "24_circle_rectangle_loft", + "25_offset_polygon_layers", + "27_split_plate", + "28_face_located_sphere_holes", + "29_occ_bottle", + "30_bezier_profile", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern", + "34_embossed_debossed_text", + "35_curved_slots", + "36_extrude_until", + "37_positioned_sketches", + "39_pegboard_j_hook", + "40_handle", + "41_pillow_block", + "42_din_rail", + "43_lego", + "44_loft", + "45_key_cap", + "47_vase", + "48_circuit_board" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BaseCurveObject", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 75, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BaseEdgeObject", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 105, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BaseLineObject", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 90, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Airfoil", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 119, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Bezier", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 240, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "30_bezier_profile" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BlendCurve", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 269, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BSpline", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 432, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "CenterArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 491, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ConstrainedArcs", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 563, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ConstrainedLines", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 819, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "DoubleTangentArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 971, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "EllipticalCenterArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1070, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "EllipticalStartArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1149, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ParabolicCenterArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1257, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "HyperbolicCenterArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1335, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "FilletPolyline", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1458, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Helix", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 1416, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "50_spring" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "IntersectingLine", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1760, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Line", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 1731, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "04_lines_and_arcs_profile", + "12_spline_profile", + "14_swept_square_tube", + "15_mirrored_profile", + "23_revolved_profile", + "29_occ_bottle", + "39_pegboard_j_hook", + "47_vase" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "PolarLine", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 1799, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "39_pegboard_j_hook" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Polyline", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 1894, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "08_i_beam", + "23_revolved_profile", + "30_bezier_profile", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "RadiusArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 1933, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "35_curved_slots", + "47_vase" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "SagittaArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 1985, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Spline", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 2023, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "12_spline_profile", + "40_handle", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "TangentArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 2080, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "JernArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 1631, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "14_swept_square_tube", + "39_pegboard_j_hook" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ThreePointArc", + "kind": "class", + "category": "object_curve", + "module": "build123d.objects_curve", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_curve.py", + "source_line": 2120, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "04_lines_and_arcs_profile", + "29_occ_bottle" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ArrowHead", + "kind": "class", + "category": "drawing_object", + "module": "build123d.drafting", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 66, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Arrow", + "kind": "class", + "category": "drawing_object", + "module": "build123d.drafting", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 108, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BaseSketchObject", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 64, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Circle", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 101, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "03_prismatic_solid", + "05_offset_cutouts", + "06_point_list_holes", + "16_mirrored_3d_parts", + "19_vertex_cutouts", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "23_revolved_profile", + "24_circle_rectangle_loft", + "27_split_plate", + "29_occ_bottle", + "36_extrude_until", + "37_positioned_sketches", + "39_pegboard_j_hook", + "40_handle", + "43_lego", + "44_loft", + "45_key_cap", + "48_circuit_board", + "50_spring" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Draft", + "kind": "class", + "category": "drawing_object", + "module": "build123d.drafting", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 163, + "signature": "(font_size: float = 5.0, font: str = 'Arial', font_style: build123d.build_enums.FontStyle = , head_type: build123d.build_enums.HeadType = , arrow_length: float = 3.0, line_width: float = 0.5, pad_around_text: float = 2.0, unit: build123d.build_enums.Unit = , number_display: build123d.build_enums.NumberDisplay = , display_units: bool = True, decimal_precision: int = 2, fractional_precision: int = 64, extension_gap: float = 2.0) -> None", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "DimensionLine", + "kind": "class", + "category": "drawing_object", + "module": "build123d.drafting", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 330, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Ellipse", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 136, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "37_positioned_sketches" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ExtensionLine", + "kind": "class", + "category": "drawing_object", + "module": "build123d.drafting", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 498, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Polygon", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 169, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Rectangle", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 206, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "03_prismatic_solid", + "05_offset_cutouts", + "07_polygon_holes", + "14_swept_square_tube", + "16_mirrored_3d_parts", + "18_face_cutout", + "24_circle_rectangle_loft", + "36_extrude_until", + "37_positioned_sketches", + "40_handle", + "41_pillow_block", + "42_din_rail", + "43_lego", + "45_key_cap", + "48_circuit_board" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "RectangleRounded", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 239, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "RegularPolygon", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 278, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "07_polygon_holes", + "11_grid_polygon_holes", + "17_face_mirror", + "19_vertex_cutouts", + "25_offset_polygon_layers", + "28_face_located_sphere_holes", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "SlotArc", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 347, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "35_curved_slots" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "SlotCenterPoint", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 377, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "SlotCenterToCenter", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 426, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "35_curved_slots" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "SlotOverall", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 470, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "42_din_rail" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Superellipse", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 517, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Text", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_sketch.py", + "source_line": 581, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "34_embossed_debossed_text" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "TechnicalDrawing", + "kind": "class", + "category": "drawing_object", + "module": "build123d.drafting", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 699, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Trapezoid", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 688, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Triangle", + "kind": "class", + "category": "object_sketch", + "module": "build123d.objects_sketch", + "conversion_status": "unverified", + "source_file": "build123d/objects_sketch.py", + "source_line": 767, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BasePartObject", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "unverified", + "source_file": "build123d/objects_part.py", + "source_line": 58, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Box", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_part.py", + "source_line": 112, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "01_rectangular_plate", + "02_plate_with_hole", + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "18_face_cutout", + "20_offset_plane_cylinder", + "22_angled_drill_holes", + "24_circle_rectangle_loft", + "26_thin_wall_box", + "27_split_plate", + "34_embossed_debossed_text", + "35_curved_slots", + "38_rotated_boxes", + "43_lego" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Cone", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "unverified", + "source_file": "build123d/objects_part.py", + "source_line": 154, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ConvexPolyhedron", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "unverified", + "source_file": "build123d/objects_part.py", + "source_line": 205, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "CounterBoreHole", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_part.py", + "source_line": 264, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "13_countersink_counterbore", + "41_pillow_block", + "49_holes" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "CounterSinkHole", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_part.py", + "source_line": 312, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "13_countersink_counterbore", + "49_holes" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Cylinder", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_part.py", + "source_line": 365, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "02_plate_with_hole", + "13_countersink_counterbore", + "43_lego", + "49_holes" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Hole", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_part.py", + "source_line": 411, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "10_filleted_hole", + "11_grid_polygon_holes", + "28_face_located_sphere_holes", + "49_holes" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Sphere", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/objects_part.py", + "source_line": 453, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "28_face_located_sphere_holes", + "45_key_cap" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Torus", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "unverified", + "source_file": "build123d/objects_part.py", + "source_line": 503, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Wedge", + "kind": "class", + "category": "object_part", + "module": "build123d.objects_part", + "conversion_status": "unverified", + "source_file": "build123d/objects_part.py", + "source_line": 557, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BoundBox", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1034, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "OrientedBoundBox", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2214, + "signature": "(shape: 'Bnd_OBB | Shape')", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Rotation", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2425, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Rot", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/geometry.py", + "source_line": 2425, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "38_rotated_boxes", + "47_vase" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Pos", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2575, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "RotationLike", + "kind": "value", + "category": "constant_or_type_alias", + "module": "types", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ShapeList", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.shape_core", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3301, + "signature": "(iterable=(), /)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "topo_distance_to", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.shape_core", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3115, + "signature": "(other: 'Shape | Iterable[Shape]') -> 'Callable[[Shape], int | float]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Axis", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/geometry.py", + "source_line": 631, + "signature": "(*args: 'Any', **kwargs: 'Any') -> 'None'", + "validation_evidence": { + "accepted_models": [ + "19_vertex_cutouts" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Color", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1380, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Curve", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.composite", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 954, + "signature": "(obj: 'TopoDS_Compound | Iterable[Shape] | None' = None, label: 'str' = '', color: 'Color | None' = None, material: 'FinishedMaterial | None' = None, joints: 'dict[str, Joint] | None' = None, parent: 'Compound | None' = None, children: 'Sequence[Shape] | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Vector", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/geometry.py", + "source_line": 163, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [ + "47_vase" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "VectorLike", + "kind": "value", + "category": "constant_or_type_alias", + "module": "types", + "conversion_status": "unverified", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Vertex", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.zero_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 89, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Edge", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.one_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1638, + "signature": "(obj: 'TopoDS_Edge | Axis | None | None' = None, label: 'str' = '', color: 'Color | None' = None, parent: 'Compound | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Wire", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.one_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3528, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Face", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.two_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 804, + "signature": "(*args: 'Any', **kwargs: 'Any')", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Matrix", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2617, + "signature": "(*args, **kwargs)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Solid", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.three_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 720, + "signature": "(obj: 'TopoDS_Solid | Shell | None' = None, label: 'str' = '', color: 'Color | None' = None, material: 'FinishedMaterial | None' = None, joints: 'dict[str, Joint] | None' = None, parent: 'Compound | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Shell", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.two_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2843, + "signature": "(obj: 'TopoDS_Shell | Face | Iterable[Face] | None' = None, label: 'str' = '', color: 'Color | None' = None, parent: 'Compound | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Part", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.composite", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 1000, + "signature": "(obj: 'TopoDS_Compound | Iterable[Shape] | None' = None, label: 'str' = '', color: 'Color | None' = None, material: 'FinishedMaterial | None' = None, joints: 'dict[str, Joint] | None' = None, parent: 'Compound | None' = None, children: 'Sequence[Shape] | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Plane", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/geometry.py", + "source_line": 2840, + "signature": "(*args: 'Any', **kwargs: 'Any') -> 'None'", + "validation_evidence": { + "accepted_models": [ + "17_face_mirror", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "27_split_plate", + "37_positioned_sketches", + "39_pegboard_j_hook", + "44_loft", + "45_key_cap" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Compound", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.composite", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/composite.py", + "source_line": 123, + "signature": "(obj: 'TopoDS_Compound | Iterable[Shape] | None' = None, label: 'str' = '', color: 'Color | None' = None, material: 'FinishedMaterial | None' = None, joints: 'dict[str, Joint] | None' = None, parent: 'Compound | None' = None, children: 'Sequence[Shape] | None' = None)", + "validation_evidence": { + "accepted_models": [ + "49_holes" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Location", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/geometry.py", + "source_line": 1739, + "signature": "(*args: 'Any', **kwargs: 'Any') -> 'None'", + "validation_evidence": { + "accepted_models": [ + "38_rotated_boxes" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "GeomEncoder", + "kind": "class", + "category": "geometry", + "module": "build123d.geometry", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1677, + "signature": "(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Joint", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.shape_core", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3936, + "signature": "(label: 'str', parent: 'BuildPart | Solid | Compound')", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "RigidJoint", + "kind": "class", + "category": "assembly_joint", + "module": "build123d.joints", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 53, + "signature": "(label: 'str', to_part: 'Solid | Compound | None' = None, joint_location: 'Location | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "RevoluteJoint", + "kind": "class", + "category": "assembly_joint", + "module": "build123d.joints", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 219, + "signature": "(label: 'str', to_part: 'Solid | Compound | None' = None, axis: 'Axis' = Axis((0, 0, 0), (0, 0, 1)), angle_reference: 'VectorLike | None' = None, angular_range: 'tuple[float, float]' = (0, 360))", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Sketch", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.composite", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 985, + "signature": "(obj: 'TopoDS_Compound | Iterable[Shape] | None' = None, label: 'str' = '', color: 'Color | None' = None, material: 'FinishedMaterial | None' = None, joints: 'dict[str, Joint] | None' = None, parent: 'Compound | None' = None, children: 'Sequence[Shape] | None' = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "LinearJoint", + "kind": "class", + "category": "assembly_joint", + "module": "build123d.joints", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 346, + "signature": "(label: 'str', to_part: 'Solid | Compound | None' = None, axis: 'Axis' = Axis((0, 0, 0), (0, 0, 1)), linear_range: 'tuple[float, float]' = (0, inf))", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "CylindricalJoint", + "kind": "class", + "category": "assembly_joint", + "module": "build123d.joints", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 516, + "signature": "(label: 'str', to_part: 'Solid | Compound | None' = None, axis: 'Axis' = Axis((0, 0, 0), (0, 0, 1)), angle_reference: 'VectorLike | None' = None, linear_range: 'tuple[float, float]' = (0, inf), angular_range: 'tuple[float, float]' = (0, 360))", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "BallJoint", + "kind": "class", + "category": "assembly_joint", + "module": "build123d.joints", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 671, + "signature": "(label: 'str', to_part: 'Solid | Compound | None' = None, joint_location: 'Location | None' = None, angular_range: 'tuple[tuple[float, float], tuple[float, float], tuple[float, float]]' = ((0, 360), (0, 360), (0, 360)), angle_reference: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)))", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "DraftAngleError", + "kind": "class", + "category": "direct_topology", + "module": "build123d.topology.three_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1849, + "signature": "(message, face=None, problematic_shape=None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "FontManager", + "kind": "class", + "category": "utility", + "module": "build123d.text", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 65, + "signature": "()", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Export2D", + "kind": "class", + "category": "export", + "module": "build123d.exporters", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 271, + "signature": "()", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ExportDXF", + "kind": "class", + "category": "export", + "module": "build123d.exporters", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 455, + "signature": "(version: str = 'AC1027', unit: build123d.build_enums.Unit = , color: build123d.exporters.ColorIndex | None = None, line_weight: float | None = None, line_type: build123d.exporters.LineType | None = None)", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "ExportSVG", + "kind": "class", + "category": "export", + "module": "build123d.exporters", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 840, + "signature": "(unit: build123d.build_enums.Unit = , scale: float = 1, margin: float = 0, fit_to_stroke: bool = True, precision: int = 6, fill_color: str | tuple[str, float | int] | tuple[float | int, float | int, float | int] | tuple[float | int, float | int, float | int, float | int] | int | tuple[int, int] | build123d.geometry.Color | OCP.OCP.Quantity.Quantity_ColorRGBA | build123d.exporters.ColorIndex | ezdxf.colors.RGB | None | typing_extensions.sentinel = INHERIT_COLOR, line_color: str | tuple[str, float | int] | tuple[float | int, float | int, float | int] | tuple[float | int, float | int, float | int, float | int] | int | tuple[int, int] | build123d.geometry.Color | OCP.OCP.Quantity.Quantity_ColorRGBA | build123d.exporters.ColorIndex | ezdxf.colors.RGB | None | typing_extensions.sentinel = INHERIT_COLOR, line_weight: float = 0.09, line_type: build123d.exporters.LineType = , dot_length: build123d.exporters.DotLength | float = )", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "LineType", + "kind": "class", + "category": "enum", + "module": "build123d.exporters", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 165, + "signature": "(*values)", + "values": [ + "CONTINUOUS", + "BORDER", + "BORDER2", + "BORDERX2", + "CENTER", + "CENTER2", + "CENTERX2", + "DASHDOT", + "DASHDOT2", + "DASHDOTX2", + "DASHED", + "DASHED2", + "DASHEDX2", + "DIVIDE", + "DIVIDE2", + "DIVIDEX2", + "DOT", + "DOT2", + "DOTX2", + "HIDDEN", + "HIDDEN2", + "HIDDENX2", + "PHANTOM", + "PHANTOM2", + "PHANTOMX2", + "ISO_DASH", + "ISO_DASH_SPACE", + "ISO_LONG_DASH_DOT", + "ISO_LONG_DASH_DOUBLE_DOT", + "ISO_LONG_DASH_TRIPLE_DOT", + "ISO_DOT", + "ISO_LONG_DASH_SHORT_DASH", + "ISO_LONG_DASH_DOUBLE_SHORT_DASH", + "ISO_DASH_DOT", + "ISO_DOUBLE_DASH_DOT", + "ISO_DASH_DOUBLE_DOT", + "ISO_DOUBLE_DASH_DOUBLE_DOT", + "ISO_DASH_TRIPLE_DOT", + "ISO_DOUBLE_DASH_TRIPLE_DOT" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "DotLength", + "kind": "class", + "category": "enum", + "module": "build123d.exporters", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 225, + "signature": "(*values)", + "values": [ + "TRUE_DOT", + "INKSCAPE_COMPAT", + "QCAD_IMPERIAL" + ], + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "Mesher", + "kind": "class", + "category": "utility", + "module": "build123d.mesher", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 122, + "signature": "(unit: build123d.build_enums.Unit = )", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "detect_primitives", + "kind": "function", + "category": "utility", + "module": "build123d.brep_from_stl", + "conversion_status": "unverified", + "source_file": "build123d/brep_from_stl.py", + "source_line": 1850, + "signature": "(mesh: 'Shape') -> 'tuple[ShapeList[Face], ShapeList[Face], list[str]]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "import_brep", + "kind": "function", + "category": "import", + "module": "build123d.importers", + "conversion_status": "unverified", + "source_file": "build123d/importers.py", + "source_line": 108, + "signature": "(file_name: os.PathLike | str | bytes) -> build123d.topology.shape_core.Shape", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "import_dxf", + "kind": "function", + "category": "import", + "module": "build123d.import_dxf", + "conversion_status": "unverified", + "source_file": "build123d/import_dxf.py", + "source_line": 461, + "signature": "(dxf_file: str | os.PathLike | typing.TextIO | typing.BinaryIO) -> build123d.topology.shape_core.ShapeList", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "import_step", + "kind": "function", + "category": "import", + "module": "build123d.importers", + "conversion_status": "unverified", + "source_file": "build123d/importers.py", + "source_line": 132, + "signature": "(filename: os.PathLike | str | bytes) -> build123d.topology.composite.Compound", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "import_stl", + "kind": "function", + "category": "import", + "module": "build123d.importers", + "conversion_status": "unverified", + "source_file": "build123d/importers.py", + "source_line": 272, + "signature": "(file_name: os.PathLike | str | bytes, model_unit: build123d.build_enums.Unit = ) -> build123d.topology.two_d.Face", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "import_svg", + "kind": "function", + "category": "import", + "module": "build123d.importers", + "conversion_status": "unverified", + "source_file": "build123d/importers.py", + "source_line": 403, + "signature": "(svg_file: str | pathlib.Path | typing.TextIO, *, flip_y: bool = True, align: build123d.build_enums.Align | tuple[build123d.build_enums.Align, build123d.build_enums.Align] | None = , ignore_visibility: bool = False, label_by: Union[Literal['id', 'class', 'inkscape:label'], str] = 'id') -> build123d.topology.shape_core.ShapeList[build123d.topology.one_d.Wire | build123d.topology.two_d.Face]", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "import_svg_as_buildline_code", + "kind": "function", + "category": "import", + "module": "build123d.importers", + "conversion_status": "unverified", + "source_file": "build123d/importers.py", + "source_line": 327, + "signature": "(file_name: os.PathLike | str | bytes, precision: int = 6) -> tuple[str, str]", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "delta", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.utils", + "conversion_status": "unverified", + "source_file": "build123d/topology/utils.py", + "source_line": 260, + "signature": "(shapes_one: 'Iterable[Shape]', shapes_two: 'Iterable[Shape]') -> 'list[Shape]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "edges_to_wires", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.one_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4731, + "signature": "(edges: 'Iterable[Edge]', tol: 'float' = 1e-06) -> 'ShapeList[Wire]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "new_edges", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.utils", + "conversion_status": "unverified", + "source_file": "build123d/topology/utils.py", + "source_line": 301, + "signature": "(*objects: 'Shape', combined: 'Shape') -> 'ShapeList[Edge]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "pack", + "kind": "function", + "category": "utility", + "module": "build123d.pack", + "conversion_status": "unverified", + "source_file": "build123d/pack.py", + "source_line": 40, + "signature": "(objects: 'Collection[Shape]', padding: 'float', align_z: 'bool' = False) -> 'Collection[Shape]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "polar", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.utils", + "conversion_status": "unverified", + "source_file": "build123d/topology/utils.py", + "source_line": 343, + "signature": "(length: 'float', angle: 'float') -> 'tuple[float, float]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "available_fonts", + "kind": "function", + "category": "utility", + "module": "build123d.text", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 307, + "signature": "() -> list[build123d.text.FontInfo]", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "solids", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 754, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Solid]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "faces", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 720, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Face]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "wires", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 686, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Wire]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "edges", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 652, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Edge]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "vertices", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 615, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Vertex]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "solid", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 771, + "signature": "(self, select: 'Select' = ) -> 'Solid'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "face", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 737, + "signature": "(self, select: 'Select' = ) -> 'Face'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "wire", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 703, + "signature": "(self, select: 'Select' = ) -> 'Wire'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "edge", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 669, + "signature": "(self, select: 'Select' = ) -> 'Edge'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "vertex", + "kind": "function", + "category": "utility", + "module": "build123d.build_common", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 635, + "signature": "(self, select: 'Select' = ) -> 'Vertex'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "add", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "unverified", + "source_file": "typing_extensions.py", + "source_line": 204, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | build123d.topology.composite.Compound | build123d.build_common.Builder | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | build123d.topology.composite.Compound | build123d.build_common.Builder], rotation: float | build123d.geometry.Rotation | tuple[float, float, float] | None = None, clean: bool = True, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Compound", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "insert", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 79, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | build123d.topology.composite.Compound | build123d.build_common.Builder | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | build123d.topology.composite.Compound | build123d.build_common.Builder], rotation: float | build123d.geometry.Rotation | tuple[float, float, float] | None = None, clean: bool = True, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Compound", + "validation_evidence": { + "accepted_models": [ + "16_mirrored_3d_parts", + "32_variable_height_pattern", + "33_function_generated_pattern", + "38_rotated_boxes" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "bounding_box", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "unverified", + "source_file": "build123d/operations_generic.py", + "source_line": 219, + "signature": "(objects: build123d.topology.shape_core.Shape | collections.abc.Iterable[build123d.topology.shape_core.Shape] | None = None, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Sketch | build123d.topology.composite.Part", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "chamfer", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 282, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.zero_d.Vertex | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.zero_d.Vertex], length: float, length2: float | None = None, angle: float | None = None, reference: build123d.topology.one_d.Edge | build123d.topology.two_d.Face | None = None) -> build123d.topology.composite.Sketch | build123d.topology.composite.Part", + "validation_evidence": { + "accepted_models": [ + "09_fillets_and_chamfers", + "11_grid_polygon_holes", + "18_face_cutout" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "draft", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "unverified", + "source_file": "build123d/operations_part.py", + "source_line": 60, + "signature": "(faces: 'Face | Iterable[Face]', neutral_plane: 'Plane', angle: 'float') -> 'Part'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "extrude", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_part.py", + "source_line": 113, + "signature": "(to_extrude: 'Face | Sketch | None' = None, amount: 'float | None' = None, dir: 'VectorLike | None' = None, until: 'Until | None' = None, target: 'Compound | Solid | None' = None, both: 'bool' = False, taper: 'float' = 0.0, clean: 'bool' = True, mode: 'Mode' = ) -> 'Part'", + "validation_evidence": { + "accepted_models": [ + "03_prismatic_solid", + "04_lines_and_arcs_profile", + "05_offset_cutouts", + "06_point_list_holes", + "07_polygon_holes", + "08_i_beam", + "11_grid_polygon_holes", + "12_spline_profile", + "15_mirrored_profile", + "16_mirrored_3d_parts", + "17_face_mirror", + "18_face_cutout", + "19_vertex_cutouts", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "25_offset_polygon_layers", + "27_split_plate", + "28_face_located_sphere_holes", + "29_occ_bottle", + "30_bezier_profile", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern", + "34_embossed_debossed_text", + "35_curved_slots", + "36_extrude_until", + "37_positioned_sketches", + "41_pillow_block", + "42_din_rail", + "43_lego", + "45_key_cap", + "48_circuit_board" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "fillet", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 406, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.zero_d.Vertex | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.zero_d.Vertex], radius: float) -> build123d.topology.composite.Sketch | build123d.topology.composite.Part | build123d.topology.composite.Curve", + "validation_evidence": { + "accepted_models": [ + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "16_mirrored_3d_parts", + "18_face_cutout", + "29_occ_bottle", + "40_handle", + "41_pillow_block", + "42_din_rail", + "45_key_cap", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "full_round", + "kind": "function", + "category": "operation", + "module": "build123d.operations_sketch", + "conversion_status": "unverified", + "source_file": "build123d/operations_sketch.py", + "source_line": 53, + "signature": "(edge: 'Edge', invert: 'bool' = False, voronoi_point_count: 'int' = 100, mode: 'Mode' = ) -> 'Sketch'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "loft", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_part.py", + "source_line": 245, + "signature": "(sections: 'Face | Sketch | Iterable[Vertex | Face | Sketch] | None' = None, ruled: 'bool' = False, clean: 'bool' = True, mode: 'Mode' = ) -> 'Part'", + "validation_evidence": { + "accepted_models": [ + "24_circle_rectangle_loft", + "44_loft" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "make_brake_formed", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "unverified", + "source_file": "build123d/operations_part.py", + "source_line": 371, + "signature": "(thickness: 'float', station_widths: 'float | Iterable[float]', line: 'Edge | Wire | Curve | None' = None, side: 'Side' = , kind: 'Kind' = , clean: 'bool' = True, mode: 'Mode' = ) -> 'Part'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "make_face", + "kind": "function", + "category": "operation", + "module": "build123d.operations_sketch", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_sketch.py", + "source_line": 198, + "signature": "(edges: 'Edge | Wire | Curve | Iterable[Edge | Wire | Curve] | None' = None, mode: 'Mode' = ) -> 'Sketch'", + "validation_evidence": { + "accepted_models": [ + "04_lines_and_arcs_profile", + "08_i_beam", + "12_spline_profile", + "15_mirrored_profile", + "23_revolved_profile", + "29_occ_bottle", + "30_bezier_profile", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "make_hull", + "kind": "function", + "category": "operation", + "module": "build123d.operations_sketch", + "conversion_status": "unverified", + "source_file": "build123d/operations_sketch.py", + "source_line": 238, + "signature": "(edges: 'Edge | Iterable[Edge] | None' = None, mode: 'Mode' = ) -> 'Sketch'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "mirror", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 512, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.composite.Compound | build123d.topology.composite.Curve | build123d.topology.composite.Sketch | build123d.topology.composite.Part | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.composite.Compound | build123d.topology.composite.Curve | build123d.topology.composite.Sketch | build123d.topology.composite.Part] | None = None, about: build123d.geometry.Plane = Plane((0, 0, 0), (1, 0, 0), (0, -1, 0)), mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Curve | build123d.topology.composite.Sketch | build123d.topology.composite.Part | build123d.topology.composite.Compound", + "validation_evidence": { + "accepted_models": [ + "08_i_beam", + "15_mirrored_profile", + "16_mirrored_3d_parts", + "17_face_mirror", + "29_occ_bottle" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "offset", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 565, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | build123d.topology.composite.Compound | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | build123d.topology.composite.Compound] | None = None, amount: float = 0, openings: build123d.topology.two_d.Face | list[build123d.topology.two_d.Face] | None = None, kind: build123d.build_enums.Kind = , side: build123d.build_enums.Side = , closed: bool = True, min_edge_length: float | None = None, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Curve | build123d.topology.composite.Sketch | build123d.topology.composite.Part | build123d.topology.composite.Compound", + "validation_evidence": { + "accepted_models": [ + "25_offset_polygon_layers", + "26_thin_wall_box", + "29_occ_bottle", + "43_lego", + "44_loft", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "project", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "unverified", + "source_file": "build123d/operations_generic.py", + "source_line": 720, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.two_d.Face | build123d.topology.one_d.Wire | build123d.geometry.Vector | build123d.topology.zero_d.Vertex | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.two_d.Face | build123d.topology.one_d.Wire | build123d.geometry.Vector | build123d.topology.zero_d.Vertex] | None = None, workplane: build123d.geometry.Plane | None = None, target: build123d.topology.three_d.Solid | build123d.topology.composite.Compound | build123d.topology.composite.Part | None = None, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Curve | build123d.topology.composite.Sketch | build123d.topology.composite.Compound | build123d.topology.shape_core.ShapeList[build123d.geometry.Vector]", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "project_workplane", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "unverified", + "source_file": "build123d/operations_part.py", + "source_line": 481, + "signature": "(origin: 'VectorLike | Vertex', x_dir: 'VectorLike | Vertex', projection_dir: 'VectorLike', distance: 'float') -> 'Plane'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "revolve", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_part.py", + "source_line": 536, + "signature": "(profiles: 'Face | Iterable[Face] | None' = None, axis: 'Axis' = Axis((0, 0, 0), (0, 0, 1)), revolution_arc: 'float' = 360.0, clean: 'bool' = True, mode: 'Mode' = ) -> 'Part'", + "validation_evidence": { + "accepted_models": [ + "23_revolved_profile", + "36_extrude_until", + "47_vase" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "scale", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 863, + "signature": "(objects: build123d.topology.shape_core.Shape | collections.abc.Iterable[build123d.topology.shape_core.Shape] | None = None, by: float | tuple[float, float, float] = 1, about: build123d.geometry.Vector | tuple[float, float] | tuple[float, float, float] | collections.abc.Sequence[float] | None = None, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Curve | build123d.topology.composite.Sketch | build123d.topology.composite.Part | build123d.topology.composite.Compound", + "validation_evidence": { + "accepted_models": [ + "45_key_cap" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "section", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_part.py", + "source_line": 591, + "signature": "(obj: 'Part | None' = None, section_by: 'Plane | Iterable[Plane]' = Plane((0, 0, 0), (1, 0, 0), (0, -1, 0)), height: 'float' = 0.0, clean: 'bool' = True, mode: 'Mode' = ) -> 'Sketch'", + "validation_evidence": { + "accepted_models": [ + "45_key_cap" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "split", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 921, + "signature": "(objects: build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | collections.abc.Iterable[build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid] | None = None, bisect_by: build123d.geometry.Plane | build123d.topology.two_d.Face | build123d.topology.two_d.Shell = Plane((0, 0, 0), (1, 0, 0), (0, -1, 0)), keep: build123d.build_enums.Keep = , mode: build123d.build_enums.Mode = )", + "validation_evidence": { + "accepted_models": [ + "23_revolved_profile", + "27_split_plate", + "39_pegboard_j_hook" + ], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "sweep", + "kind": "function", + "category": "operation", + "module": "build123d.operations_generic", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/operations_generic.py", + "source_line": 984, + "signature": "(sections: build123d.topology.composite.Compound | build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid | collections.abc.Iterable[build123d.topology.composite.Compound | build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | build123d.topology.two_d.Face | build123d.topology.three_d.Solid] | None = None, path: build123d.topology.composite.Curve | build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | collections.abc.Iterable[build123d.topology.one_d.Edge] | None = None, multisection: bool = False, is_frenet: bool = False, transition: build123d.build_enums.Transition = , normal: build123d.geometry.Vector | tuple[float, float] | tuple[float, float, float] | collections.abc.Sequence[float] | None = None, binormal: build123d.topology.one_d.Edge | build123d.topology.one_d.Wire | None = None, clean: bool = True, mode: build123d.build_enums.Mode = ) -> build123d.topology.composite.Part | build123d.topology.composite.Sketch", + "validation_evidence": { + "accepted_models": [ + "14_swept_square_tube", + "39_pegboard_j_hook", + "40_handle", + "50_spring" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "thicken", + "kind": "function", + "category": "operation", + "module": "build123d.operations_part", + "conversion_status": "unverified", + "source_file": "build123d/operations_part.py", + "source_line": 658, + "signature": "(to_thicken: 'Face | Sketch | None' = None, amount: 'float | None' = None, normal_override: 'VectorLike | None' = None, both: 'bool' = False, clean: 'bool' = True, mode: 'Mode' = ) -> 'Part'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "trace", + "kind": "function", + "category": "operation", + "module": "build123d.operations_sketch", + "conversion_status": "unverified", + "source_file": "build123d/operations_sketch.py", + "source_line": 276, + "signature": "(lines: 'Curve | Edge | Wire | Iterable[Curve | Edge | Wire] | None' = None, line_width: 'float' = 1, mode: 'Mode' = ) -> 'Sketch'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "topo_explore_connected_edges", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.one_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4767, + "signature": "(edge: 'Edge', parent: 'Shape | None' = None, continuity: 'ContinuityLevel' = ) -> 'ShapeList[Edge]'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "topo_explore_common_vertex", + "kind": "function", + "category": "direct_topology", + "module": "build123d.topology.zero_d", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 465, + "signature": "(edge1: 'Edge | TopoDS_Edge', edge2: 'Edge | TopoDS_Edge') -> 'Vertex | None'", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "export_step", + "kind": "function", + "category": "export", + "module": "build123d.exporters3d", + "conversion_status": "unverified", + "source_file": "build123d/exporters3d.py", + "source_line": 364, + "signature": "(to_export: build123d.topology.shape_core.Shape, file_path: os.PathLike | str | bytes | _io.BytesIO | typing.BinaryIO, unit: build123d.build_enums.Unit = , write_pcurves: bool = True, precision_mode: build123d.build_enums.PrecisionMode = , *, timestamp: str | datetime.datetime | None = None) -> bool", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "export_gltf", + "kind": "function", + "category": "export", + "module": "build123d.exporters3d", + "conversion_status": "unverified", + "source_file": "build123d/exporters3d.py", + "source_line": 260, + "signature": "(to_export: build123d.topology.shape_core.Shape, file_path: os.PathLike | str | bytes, unit: build123d.build_enums.Unit = , binary: bool = False, linear_deflection: float = 0.001, angular_deflection: float = 0.1) -> bool", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "export_stl", + "kind": "function", + "category": "export", + "module": "build123d.exporters3d", + "conversion_status": "unverified", + "source_file": "build123d/exporters3d.py", + "source_line": 449, + "signature": "(to_export: build123d.topology.shape_core.Shape, file_path: os.PathLike | str | bytes, tolerance: float = 0.001, angular_tolerance: float = 0.1, ascii_format: bool = False) -> bool", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "export_brep", + "kind": "function", + "category": "export", + "module": "build123d.exporters3d", + "conversion_status": "unverified", + "source_file": "build123d/exporters3d.py", + "source_line": 238, + "signature": "(to_export: build123d.topology.shape_core.Shape, file_path: os.PathLike | str | bytes | _io.BytesIO | typing.BinaryIO) -> bool", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "export_obj", + "kind": "function", + "category": "export", + "module": "build123d.exporters3d", + "conversion_status": "unverified", + "source_file": "build123d/exporters3d.py", + "source_line": 494, + "signature": "(to_export: build123d.topology.shape_core.Shape, file_path: os.PathLike | str | bytes | _io.BytesIO | typing.BinaryIO, linear_deflection: float = 0.001, angular_deflection: float = 0.1, include_uvs: bool = True, atlas_packing: bool = True, atlas_gutter: float = 0.0) -> bool", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + }, + { + "name": "export_to_pcbway", + "kind": "function", + "category": "export", + "module": "build123d.exporters3d", + "conversion_status": "unverified", + "source_file": "build123d/exporters3d.py", + "source_line": 580, + "signature": "(to_export: build123d.topology.shape_core.Shape, unit: build123d.build_enums.Unit = , write_pcurves: bool = True, precision_mode: build123d.build_enums.PrecisionMode = ) -> str", + "validation_evidence": { + "accepted_models": [], + "rejected_or_unverified_models": [], + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified." + } + } + ], + "members": { + "build123d.topology.shape_core.Shape.__add__": { + "name": "__add__", + "owner": "build123d.topology.shape_core.Shape", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1100, + "signature": "(self, other)" + }, + "build123d.topology.shape_core.Shape.__and__": { + "name": "__and__", + "owner": "build123d.topology.shape_core.Shape", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1135, + "signature": "(self, other: 'Shape | Iterable[Shape]') -> 'None | Self | Compound'" + }, + "build123d.topology.shape_core.Shape.__rmul__": { + "name": "__rmul__", + "owner": "build123d.topology.shape_core.Shape", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1221, + "signature": "(self, other: 'Plane | Location | Iterable[Plane | Location]')" + }, + "build123d.topology.shape_core.Shape.__sub__": { + "name": "__sub__", + "owner": "build123d.topology.shape_core.Shape", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1229, + "signature": "(self, other)" + }, + "build123d.topology.shape_core.Shape.area": { + "name": "area", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 391, + "signature": "(self) -> 'float'" + }, + "build123d.topology.shape_core.Shape.as_shape": { + "name": "as_shape", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 783, + "signature": "(cls, obj: 'Shape | Vector | Location | Axis | Plane') -> 'Shape'" + }, + "build123d.topology.shape_core.Shape.bounding_box": { + "name": "bounding_box", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1327, + "signature": "(self, tolerance: 'float | None' = None, optimal: 'bool' = True) -> 'BoundBox'" + }, + "build123d.topology.shape_core.Shape.cast": { + "name": "cast", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 801, + "signature": "(cls, obj: 'TopoDS_Shape') -> 'Shape'" + }, + "build123d.topology.shape_core.Shape.clean": { + "name": "clean", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1346, + "signature": "(self) -> 'Self'" + }, + "build123d.topology.shape_core.Shape.closest_points": { + "name": "closest_points", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1374, + "signature": "(self, other: 'Shape | VectorLike') -> 'tuple[Vector, Vector]'" + }, + "build123d.topology.shape_core.Shape.color": { + "name": "color", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 401, + "signature": "(self) -> 'None | Color'" + }, + "build123d.topology.shape_core.Shape.combined_center": { + "name": "combined_center", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 909, + "signature": "(objects: 'Iterable[Shape]', center_of: 'CenterOf' = ) -> 'Vector'" + }, + "build123d.topology.shape_core.Shape.compound": { + "name": "compound", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1378, + "signature": "(self) -> 'Compound'" + }, + "build123d.topology.shape_core.Shape.compounds": { + "name": "compounds", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1382, + "signature": "(self) -> 'ShapeList[Compound]'" + }, + "build123d.topology.shape_core.Shape.compute_mass": { + "name": "compute_mass", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1288, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.shape_core.Shape.compute_volume": { + "name": "compute_volume", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1269, + "signature": "(self) -> 'float'" + }, + "build123d.topology.shape_core.Shape.convexity": { + "name": "convexity", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 469, + "signature": "(self) -> 'Convexity'" + }, + "build123d.topology.shape_core.Shape.copy_attributes_to": { + "name": "copy_attributes_to", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1386, + "signature": "(self, target: 'Shape', exceptions: 'Iterable[str] | None' = None)" + }, + "build123d.topology.shape_core.Shape.cut": { + "name": "cut", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1418, + "signature": "(self, *to_cut: 'Shape') -> 'Self | Compound'", + "validation_evidence": { + "accepted_models": [ + "02_plate_with_hole", + "10_filleted_hole", + "11_grid_polygon_holes", + "13_countersink_counterbore", + "18_face_cutout", + "19_vertex_cutouts", + "22_angled_drill_holes", + "27_split_plate", + "28_face_located_sphere_holes", + "34_embossed_debossed_text", + "35_curved_slots", + "41_pillow_block", + "42_din_rail", + "45_key_cap", + "49_holes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.distance": { + "name": "distance", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1432, + "signature": "(self, other: 'Shape') -> 'float'" + }, + "build123d.topology.shape_core.Shape.distance_to": { + "name": "distance_to", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1446, + "signature": "(self, other: 'Shape | VectorLike') -> 'float'" + }, + "build123d.topology.shape_core.Shape.distance_to_with_closest_points": { + "name": "distance_to_with_closest_points", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1450, + "signature": "(self, other: 'Shape | VectorLike') -> 'tuple[float, Vector, Vector]'" + }, + "build123d.topology.shape_core.Shape.distances": { + "name": "distances", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1475, + "signature": "(self, *others: 'Shape') -> 'Iterator[float]'" + }, + "build123d.topology.shape_core.Shape.edge": { + "name": "edge", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1498, + "signature": "(self) -> 'Edge'" + }, + "build123d.topology.shape_core.Shape.edges": { + "name": "edges", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1502, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Edge]'" + }, + "build123d.topology.shape_core.Shape.entities": { + "name": "entities", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1538, + "signature": "(self, topo_type: 'Shapes') -> 'list[TopoDS_Shape]'" + }, + "build123d.topology.shape_core.Shape.extrude": { + "name": "extrude", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 812, + "signature": "(cls, obj: 'Shape', direction: 'VectorLike') -> 'Edge | Face | Shell | Solid | Compound'" + }, + "build123d.topology.shape_core.Shape.face": { + "name": "face", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1544, + "signature": "(self) -> 'Face'" + }, + "build123d.topology.shape_core.Shape.faces": { + "name": "faces", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1548, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Face]'" + }, + "build123d.topology.shape_core.Shape.faces_intersected_by_axis": { + "name": "faces_intersected_by_axis", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1552, + "signature": "(self, axis: 'Axis', tol: 'float' = 0.0001) -> 'ShapeList[Face]'" + }, + "build123d.topology.shape_core.Shape.fix": { + "name": "fix", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1596, + "signature": "(self) -> 'Self'" + }, + "build123d.topology.shape_core.Shape.fuse": { + "name": "fuse", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1608, + "signature": "(self, *to_fuse: 'Shape', glue: 'bool' = False, tol: 'float | None' = None) -> 'Self | Compound'", + "validation_evidence": { + "accepted_models": [ + "13_countersink_counterbore", + "16_mirrored_3d_parts", + "17_face_mirror", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "24_circle_rectangle_loft", + "25_offset_polygon_layers", + "29_occ_bottle", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern", + "34_embossed_debossed_text", + "36_extrude_until", + "37_positioned_sketches", + "38_rotated_boxes", + "39_pegboard_j_hook", + "41_pillow_block", + "42_din_rail", + "43_lego", + "45_key_cap", + "49_holes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.geom_type": { + "name": "geom_type", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 486, + "signature": "(self) -> 'GeomType'" + }, + "build123d.topology.shape_core.Shape.get_shape_list": { + "name": "get_shape_list", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 997, + "signature": "(shape: 'Shape', entity_type: \"Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'Compound']\") -> 'ShapeList'" + }, + "build123d.topology.shape_core.Shape.get_single_shape": { + "name": "get_single_shape", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1044, + "signature": "(shape: 'Shape', entity_type: \"Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'Compound']\") -> 'Shape'" + }, + "build123d.topology.shape_core.Shape.get_top_level_shapes": { + "name": "get_top_level_shapes", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1659, + "signature": "(self) -> 'ShapeList[Shape]'" + }, + "build123d.topology.shape_core.Shape.global_location": { + "name": "global_location", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 590, + "signature": "(self) -> 'Location'" + }, + "build123d.topology.shape_core.Shape.intersect": { + "name": "intersect", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1683, + "signature": "(self, *to_intersect: 'Shape | Vector | Location | Axis | Plane', tolerance: 'float' = 1e-06, include_touched: 'bool' = False) -> 'ShapeList | None'" + }, + "build123d.topology.shape_core.Shape.is_equal": { + "name": "is_equal", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1770, + "signature": "(self, other: 'Shape') -> 'bool'" + }, + "build123d.topology.shape_core.Shape.is_manifold": { + "name": "is_manifold", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 512, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.shape_core.Shape.is_null": { + "name": "is_null", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 570, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.shape_core.Shape.is_same": { + "name": "is_same", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1785, + "signature": "(self, other: 'Shape') -> 'bool'" + }, + "build123d.topology.shape_core.Shape.is_valid": { + "name": "is_valid", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 578, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.shape_core.Shape.locate": { + "name": "locate", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1800, + "signature": "(self, loc: 'Location') -> 'Self'" + }, + "build123d.topology.shape_core.Shape.located": { + "name": "located", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1815, + "signature": "(self, loc: 'Location') -> 'Self'" + }, + "build123d.topology.shape_core.Shape.location": { + "name": "location", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 607, + "signature": "(self) -> 'Location'" + }, + "build123d.topology.shape_core.Shape.make_composite": { + "name": "make_composite", + "owner": "build123d.topology.shape_core.Shape", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1074, + "signature": "(cls, shapes: 'Iterable[Shape]', dimension: 'int | None' = None) -> 'Shape'" + }, + "build123d.topology.shape_core.Shape.material": { + "name": "material", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 425, + "signature": "(self) -> 'None | FinishedMaterial'" + }, + "build123d.topology.shape_core.Shape.matrix_of_inertia": { + "name": "matrix_of_inertia", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 620, + "signature": "(self) -> 'list[list[float]]'" + }, + "build123d.topology.shape_core.Shape.mesh": { + "name": "mesh", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1832, + "signature": "(self, tolerance: 'float', angular_tolerance: 'float' = 0.1)" + }, + "build123d.topology.shape_core.Shape.mirror": { + "name": "mirror", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1850, + "signature": "(self, mirror_plane: 'Plane | None' = None) -> 'Self'", + "validation_evidence": { + "accepted_models": [ + "16_mirrored_3d_parts", + "17_face_mirror" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.move": { + "name": "move", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1872, + "signature": "(self, loc: 'Location') -> 'Self'", + "validation_evidence": { + "accepted_models": [ + "01_rectangular_plate", + "02_plate_with_hole", + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "13_countersink_counterbore", + "18_face_cutout", + "20_offset_plane_cylinder", + "22_angled_drill_holes", + "24_circle_rectangle_loft", + "26_thin_wall_box", + "27_split_plate", + "28_face_located_sphere_holes", + "34_embossed_debossed_text", + "35_curved_slots", + "38_rotated_boxes", + "43_lego", + "45_key_cap", + "49_holes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.moved": { + "name": "moved", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1888, + "signature": "(self, loc: 'Location | Plane') -> 'Self'", + "validation_evidence": { + "accepted_models": [ + "13_countersink_counterbore", + "16_mirrored_3d_parts", + "28_face_located_sphere_holes", + "38_rotated_boxes", + "41_pillow_block", + "43_lego", + "45_key_cap", + "47_vase", + "49_holes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.orientation": { + "name": "orientation", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 664, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.shape_core.Shape.oriented_bounding_box": { + "name": "oriented_bounding_box", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1907, + "signature": "(self) -> 'OrientedBoundBox'" + }, + "build123d.topology.shape_core.Shape.position": { + "name": "position", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 679, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.shape_core.Shape.principal_properties": { + "name": "principal_properties", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 694, + "signature": "(self) -> 'list[tuple[Vector, float]]'" + }, + "build123d.topology.shape_core.Shape.project_faces": { + "name": "project_faces", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1917, + "signature": "(self, faces: 'list[Face] | Compound', path: 'Wire | Edge', start: 'float' = 0) -> 'ShapeList[Face]'" + }, + "build123d.topology.shape_core.Shape.radius_of_gyration": { + "name": "radius_of_gyration", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1987, + "signature": "(self, axis: 'Axis') -> 'float'" + }, + "build123d.topology.shape_core.Shape.register_composite_factory": { + "name": "register_composite_factory", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1066, + "signature": "(cls, dimension: 'int | None', factory: 'CompositeFactory') -> 'None'" + }, + "build123d.topology.shape_core.Shape.register_geometry_constructor": { + "name": "register_geometry_constructor", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 772, + "signature": "(cls, geometry_type: 'type', constructor: 'GeometryConstructor') -> 'None'" + }, + "build123d.topology.shape_core.Shape.register_shape_constructor": { + "name": "register_shape_constructor", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 760, + "signature": "(cls, shape_type: 'TopAbs_ShapeEnum', constructor: 'ShapeConstructor') -> 'None'" + }, + "build123d.topology.shape_core.Shape.rotate": { + "name": "rotate", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2021, + "signature": "(self, axis: 'Axis', angle: 'float', transform: 'bool' = False) -> 'Self'", + "validation_evidence": { + "accepted_models": [ + "38_rotated_boxes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.scale": { + "name": "scale", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2047, + "signature": "(self, factor: 'float | tuple[float, float, float]', about: 'VectorLike | None' = None) -> 'Self'", + "validation_evidence": { + "accepted_models": [ + "45_key_cap" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.shape_type": { + "name": "shape_type", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 724, + "signature": "(self) -> 'Shapes'" + }, + "build123d.topology.shape_core.Shape.shell": { + "name": "shell", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2107, + "signature": "(self) -> 'Shell'" + }, + "build123d.topology.shape_core.Shape.shells": { + "name": "shells", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2111, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Shell]'" + }, + "build123d.topology.shape_core.Shape.show_topology": { + "name": "show_topology", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2115, + "signature": "(self, limit_class: \"Literal['Compound', 'Edge', 'Face', 'Shell', 'Solid', 'Vertex', 'Wire']\" = 'Vertex', show_center: 'bool | None' = None) -> 'str'" + }, + "build123d.topology.shape_core.Shape.solid": { + "name": "solid", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2165, + "signature": "(self) -> 'Solid'" + }, + "build123d.topology.shape_core.Shape.solids": { + "name": "solids", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2169, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Solid]'", + "validation_evidence": { + "accepted_models": [ + "22_angled_drill_holes", + "43_lego" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.split": { + "name": "split", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2200, + "signature": "(self, tool: 'TrimmingTool', keep: 'Keep' = )", + "validation_evidence": { + "accepted_models": [ + "27_split_plate", + "39_pegboard_j_hook" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.shape_core.Shape.static_moments": { + "name": "static_moments", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 729, + "signature": "(self) -> 'tuple[float, float, float]'" + }, + "build123d.topology.shape_core.Shape.tessellate": { + "name": "tessellate", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2322, + "signature": "(self, tolerance: 'float', angular_tolerance: 'float' = 0.1) -> 'tuple[list[Vector], list[tuple[int, int, int]]]'" + }, + "build123d.topology.shape_core.Shape.tessellate_with_uvs": { + "name": "tessellate_with_uvs", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2371, + "signature": "(self, tolerance: 'float', angular_tolerance: 'float' = 0.1, atlas_packing: 'bool' = True, atlas_gutter: 'float' = 0.0) -> 'tuple[list[Vector], list[tuple[int, int, int]], list[Vector], list[tuple[float, float]]]'" + }, + "build123d.topology.shape_core.Shape.to_splines": { + "name": "to_splines", + "owner": "build123d.topology.shape_core.Shape", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2590, + "signature": "(self, degree: 'int' = 3, tolerance: 'float' = 0.001, nurbs: 'bool' = False) -> 'Self'" + }, + "build123d.topology.shape_core.Shape.topo_owner": { + "name": "topo_owner", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 359, + "signature": "(self) -> 'Shape | None'" + }, + "build123d.topology.shape_core.Shape.topo_parent": { + "name": "topo_parent", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 345, + "signature": "(self) -> 'Shape | None'" + }, + "build123d.topology.shape_core.Shape.touch": { + "name": "touch", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 1753, + "signature": "(self, other: 'Shape', tolerance: 'float' = 1e-06) -> 'ShapeList'" + }, + "build123d.topology.shape_core.Shape.transform_geometry": { + "name": "transform_geometry", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2627, + "signature": "(self, t_matrix: 'Matrix') -> 'Self'" + }, + "build123d.topology.shape_core.Shape.transform_shape": { + "name": "transform_shape", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2654, + "signature": "(self, t_matrix: 'Matrix') -> 'Self'" + }, + "build123d.topology.shape_core.Shape.transformed": { + "name": "transformed", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2677, + "signature": "(self, rotate: 'VectorLike' = (0, 0, 0), offset: 'VectorLike' = (0, 0, 0)) -> 'Self'" + }, + "build123d.topology.shape_core.Shape.translate": { + "name": "translate", + "owner": "build123d.topology.shape_core.Shape", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2706, + "signature": "(self, vector: 'VectorLike', transform: 'bool' = False) -> 'Self'" + }, + "build123d.topology.shape_core.Shape.vertex": { + "name": "vertex", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2962, + "signature": "(self) -> 'Vertex'" + }, + "build123d.topology.shape_core.Shape.vertices": { + "name": "vertices", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2966, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Vertex]'" + }, + "build123d.topology.shape_core.Shape.wire": { + "name": "wire", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2729, + "signature": "(self) -> 'Wire'" + }, + "build123d.topology.shape_core.Shape.wires": { + "name": "wires", + "owner": "build123d.topology.shape_core.Shape", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 2733, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Wire]'" + }, + "build123d.topology.shape_core.Shape.wrapped": { + "name": "wrapped", + "owner": "build123d.topology.shape_core.Shape", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 373, + "signature": "(self)" + }, + "build123d.topology.one_d.Mixin1D.__add__": { + "name": "__add__", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 682, + "signature": "(self, other: 'None | Shape | Iterable[Shape]') -> 'Edge | Wire | Curve | Self'" + }, + "build123d.topology.one_d.Mixin1D.__matmul__": { + "name": "__matmul__", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 739, + "signature": "(self, position: 'float') -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.__mod__": { + "name": "__mod__", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 743, + "signature": "(self, position: 'float') -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.__xor__": { + "name": "__xor__", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 747, + "signature": "(self, position: 'float') -> 'Location'" + }, + "build123d.topology.one_d.Mixin1D.center": { + "name": "center", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 751, + "signature": "(self, center_of: 'CenterOf' = ) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.common_plane": { + "name": "common_plane", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 775, + "signature": "(self, *lines: 'Edge | Wire | None', tolerance: 'float' = 1e-06) -> 'None | Plane'" + }, + "build123d.topology.one_d.Mixin1D.convexity": { + "name": "convexity", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 564, + "signature": "(self) -> 'Convexity'" + }, + "build123d.topology.one_d.Mixin1D.curvature_comb": { + "name": "curvature_comb", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 862, + "signature": "(self, count: 'int' = 100, max_tooth_size: 'float | None' = None) -> 'ShapeList[Edge]'" + }, + "build123d.topology.one_d.Mixin1D.derivative_at": { + "name": "derivative_at", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 945, + "signature": "(self, position: 'float | VectorLike', order: 'int' = 2, position_mode: 'PositionMode' = ) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.end_point": { + "name": "end_point", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 998, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.extrude": { + "name": "extrude", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 654, + "signature": "(cls, obj: 'Shape', direction: 'VectorLike') -> 'Edge | Face | Shell | Solid | Compound'" + }, + "build123d.topology.one_d.Mixin1D.is_closed": { + "name": "is_closed", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 550, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.one_d.Mixin1D.is_forward": { + "name": "is_forward", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 557, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.one_d.Mixin1D.is_interior": { + "name": "is_interior", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 599, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.one_d.Mixin1D.length": { + "name": "length", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 612, + "signature": "(self) -> 'float'" + }, + "build123d.topology.one_d.Mixin1D.location_at": { + "name": "location_at", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1072, + "signature": "(self, distance: 'float', position_mode: 'PositionMode' = , frame_method: 'FrameMethod' = , x_dir: 'VectorLike | None' = None) -> 'Location'" + }, + "build123d.topology.one_d.Mixin1D.locations": { + "name": "locations", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1171, + "signature": "(self, distances: 'Iterable[float]', position_mode: 'PositionMode' = , frame_method: 'FrameMethod' = , x_dir: 'VectorLike | None' = None) -> 'list[Location]'" + }, + "build123d.topology.one_d.Mixin1D.mass": { + "name": "mass", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 647, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.one_d.Mixin1D.normal": { + "name": "normal", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1200, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.offset_2d": { + "name": "offset_2d", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1234, + "signature": "(self, distance: 'float', kind: 'Kind' = , side: 'Side' = , closed: 'bool' = True) -> 'Edge | Wire'" + }, + "build123d.topology.one_d.Mixin1D.perpendicular_line": { + "name": "perpendicular_line", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1331, + "signature": "(self, length: 'float', u_value: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'Edge'" + }, + "build123d.topology.one_d.Mixin1D.position_at": { + "name": "position_at", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1356, + "signature": "(self, position: 'float', position_mode: 'PositionMode' = ) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.positions": { + "name": "positions", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1384, + "signature": "(self, distances: 'Iterable[float] | None' = None, position_mode: 'PositionMode' = , deflection: 'float | None' = None) -> 'list[Vector]'" + }, + "build123d.topology.one_d.Mixin1D.project": { + "name": "project", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1432, + "signature": "(self, face: 'Face', direction: 'VectorLike', closest: 'bool' = True) -> 'Edge | Wire | ShapeList[Edge | Wire]'" + }, + "build123d.topology.one_d.Mixin1D.project_to_viewport": { + "name": "project_to_viewport", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1479, + "signature": "(self, viewport_origin: 'VectorLike', viewport_up: 'VectorLike' = (0, 0, 1), look_at: 'VectorLike | None' = None, focus: 'float | None' = None) -> 'tuple[ShapeList[Edge], ShapeList[Edge]]'" + }, + "build123d.topology.one_d.Mixin1D.radius": { + "name": "radius", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 619, + "signature": "(self) -> 'float'" + }, + "build123d.topology.one_d.Mixin1D.start_point": { + "name": "start_point", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1577, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.tangent_angle_at": { + "name": "tangent_angle_at", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1587, + "signature": "(self, location_param: 'float' = 0.5, position_mode: 'PositionMode' = , plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'float'" + }, + "build123d.topology.one_d.Mixin1D.tangent_at": { + "name": "tangent_at", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1610, + "signature": "(self, position: 'float | VectorLike' = 0.5, position_mode: 'PositionMode' = ) -> 'Vector'" + }, + "build123d.topology.one_d.Mixin1D.volume": { + "name": "volume", + "owner": "build123d.topology.one_d.Mixin1D", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 642, + "signature": "(self) -> 'float'" + }, + "build123d.topology.two_d.Mixin2D.__neg__": { + "name": "__neg__", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 207, + "signature": "(self) -> 'Self'" + }, + "build123d.topology.two_d.Mixin2D.extrude": { + "name": "extrude", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 198, + "signature": "(cls, obj: 'Shape', direction: 'VectorLike') -> 'Edge | Face | Shell | Solid | Compound'" + }, + "build123d.topology.two_d.Mixin2D.find_intersection_points": { + "name": "find_intersection_points", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 373, + "signature": "(self, other: 'Axis', tolerance: 'float' = 1e-06) -> 'list[tuple[Vector, Vector]]'" + }, + "build123d.topology.two_d.Mixin2D.location_at": { + "name": "location_at", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 625, + "signature": "(self, *args: 'Any', **kwargs: 'Any') -> 'Location'" + }, + "build123d.topology.two_d.Mixin2D.offset": { + "name": "offset", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 629, + "signature": "(self, amount: 'float') -> 'Self'" + }, + "build123d.topology.two_d.Mixin2D.project_to_viewport": { + "name": "project_to_viewport", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 633, + "signature": "(self, viewport_origin: 'VectorLike', viewport_up: 'VectorLike' = (0, 0, 1), look_at: 'VectorLike | None' = None, focus: 'float | None' = None) -> 'tuple[ShapeList[Edge], ShapeList[Edge]]'" + }, + "build123d.topology.two_d.Mixin2D.split_by_perimeter": { + "name": "split_by_perimeter", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 240, + "signature": "(self, perimeter: 'Edge | Wire', keep: 'Keep' = )" + }, + "build123d.topology.two_d.Mixin2D.touch": { + "name": "touch", + "owner": "build123d.topology.two_d.Mixin2D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 522, + "signature": "(self, other: 'Shape', tolerance: 'float' = 1e-06, found_faces: 'ShapeList | None' = None, found_edges: 'ShapeList | None' = None) -> 'ShapeList'" + }, + "build123d.topology.three_d.Mixin3D.center": { + "name": "center", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 195, + "signature": "(self, center_of: 'CenterOf' = ) -> 'Vector'" + }, + "build123d.topology.three_d.Mixin3D.chamfer": { + "name": "chamfer", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "feature", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 222, + "signature": "(self, length: 'float', length2: 'float | None', edge_list: 'Iterable[Edge]', face: 'Face | None' = None) -> 'Solid | Part'", + "validation_evidence": { + "accepted_models": [ + "09_fillets_and_chamfers", + "11_grid_polygon_holes", + "18_face_cutout" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Mixin3D.dprism": { + "name": "dprism", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 293, + "signature": "(self, basis: 'Face | None', bounds: 'list[Face | Wire]', depth: 'float | None' = None, taper: 'float' = 0, up_to_face: 'Face | None' = None, thru_all: 'bool' = True, additive: 'bool' = True) -> 'Solid'" + }, + "build123d.topology.three_d.Mixin3D.extrude": { + "name": "extrude", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 170, + "signature": "(cls, obj: 'Shape', direction: 'VectorLike') -> 'Edge | Face | Shell | Solid | Compound'" + }, + "build123d.topology.three_d.Mixin3D.fillet": { + "name": "fillet", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "feature", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 347, + "signature": "(self, radius: 'float', edge_list: 'Iterable[Edge]') -> 'Solid | Part'", + "validation_evidence": { + "accepted_models": [ + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "18_face_cutout", + "29_occ_bottle", + "45_key_cap", + "47_vase" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Mixin3D.find_intersection_points": { + "name": "find_intersection_points", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 373, + "signature": "(self, other: 'Axis', tolerance: 'float' = 1e-06) -> 'list[tuple[Vector, Vector]]'" + }, + "build123d.topology.three_d.Mixin3D.hollow": { + "name": "hollow", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 382, + "signature": "(self, faces: 'Iterable[Face] | None', thickness: 'float', tolerance: 'float' = 0.0001, kind: 'Kind' = ) -> 'Solid'" + }, + "build123d.topology.three_d.Mixin3D.is_inside": { + "name": "is_inside", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 529, + "signature": "(self, point: 'VectorLike', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.topology.three_d.Mixin3D.max_fillet": { + "name": "max_fillet", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 548, + "signature": "(self, edge_list: 'Iterable[Edge]', tolerance=0.1, max_iterations: 'int' = 10) -> 'float'" + }, + "build123d.topology.three_d.Mixin3D.offset_3d": { + "name": "offset_3d", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "feature", + "descriptor": "method", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 626, + "signature": "(self, openings: 'Iterable[Face] | None', thickness: 'float', tolerance: 'float' = 0.0001, kind: 'Kind' = ) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "26_thin_wall_box", + "29_occ_bottle", + "44_loft", + "47_vase" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Mixin3D.project_to_viewport": { + "name": "project_to_viewport", + "owner": "build123d.topology.three_d.Mixin3D", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 692, + "signature": "(self, viewport_origin: 'VectorLike', viewport_up: 'VectorLike' = (0, 0, 1), look_at: 'VectorLike | None' = None, focus: 'float | None' = None) -> 'tuple[ShapeList[Edge], ShapeList[Edge]]'" + }, + "build123d.build_common.Builder.__add__": { + "name": "__add__", + "owner": "build123d.build_common.Builder", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 886, + "signature": "(self, _other) -> 'Self'" + }, + "build123d.build_common.Builder.__and__": { + "name": "__and__", + "owner": "build123d.build_common.Builder", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 894, + "signature": "(self, _other) -> 'Self'" + }, + "build123d.build_common.Builder.__enter__": { + "name": "__enter__", + "owner": "build123d.build_common.Builder", + "category": "context_lifecycle", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 268, + "signature": "(self) -> 'Self'" + }, + "build123d.build_common.Builder.__exit__": { + "name": "__exit__", + "owner": "build123d.build_common.Builder", + "category": "context_lifecycle", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 322, + "signature": "(self, exception_type, exception_value, traceback)" + }, + "build123d.build_common.Builder.__sub__": { + "name": "__sub__", + "owner": "build123d.build_common.Builder", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 890, + "signature": "(self, _other) -> 'Self'" + }, + "build123d.build_common.Builder.edge": { + "name": "edge", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 669, + "signature": "(self, select: 'Select' = ) -> 'Edge'" + }, + "build123d.build_common.Builder.edges": { + "name": "edges", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 652, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Edge]'" + }, + "build123d.build_common.Builder.face": { + "name": "face", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 737, + "signature": "(self, select: 'Select' = ) -> 'Face'" + }, + "build123d.build_common.Builder.faces": { + "name": "faces", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 720, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Face]'" + }, + "build123d.build_common.Builder.label": { + "name": "label", + "owner": "build123d.build_common.Builder", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 252, + "signature": "(self) -> 'str'" + }, + "build123d.build_common.Builder.lasts": { + "name": "lasts", + "owner": "build123d.build_common.Builder", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 804, + "signature": "(self) -> 'dict'" + }, + "build123d.build_common.Builder.max_dimension": { + "name": "max_dimension", + "owner": "build123d.build_common.Builder", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 247, + "signature": "(self) -> 'float'" + }, + "build123d.build_common.Builder.new_edges": { + "name": "new_edges", + "owner": "build123d.build_common.Builder", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "typing_extensions.py", + "source_line": 262, + "signature": "(self) -> 'ShapeList[Edge]'" + }, + "build123d.build_common.Builder.news": { + "name": "news", + "owner": "build123d.build_common.Builder", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 811, + "signature": "(self) -> 'dict'" + }, + "build123d.build_common.Builder.solid": { + "name": "solid", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 771, + "signature": "(self, select: 'Select' = ) -> 'Solid'" + }, + "build123d.build_common.Builder.solids": { + "name": "solids", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 754, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Solid]'" + }, + "build123d.build_common.Builder.validate_inputs": { + "name": "validate_inputs", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 837, + "signature": "(self, validating_class, objects: 'Shape | Iterable[Shape] | None' = None)" + }, + "build123d.build_common.Builder.vertex": { + "name": "vertex", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 635, + "signature": "(self, select: 'Select' = ) -> 'Vertex'" + }, + "build123d.build_common.Builder.vertices": { + "name": "vertices", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 615, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Vertex]'" + }, + "build123d.build_common.Builder.wire": { + "name": "wire", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 703, + "signature": "(self, select: 'Select' = ) -> 'Wire'" + }, + "build123d.build_common.Builder.wires": { + "name": "wires", + "owner": "build123d.build_common.Builder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 686, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Wire]'" + }, + "build123d.build_common.BaseObjectMeta.__call__": { + "name": "__call__", + "owner": "build123d.build_common.BaseObjectMeta", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 1527, + "signature": "(cls, *args, **kwargs)" + }, + "build123d.build_common.LocationList.__enter__": { + "name": "__enter__", + "owner": "build123d.build_common.LocationList", + "category": "context_lifecycle", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 939, + "signature": "(self)" + }, + "build123d.build_common.LocationList.__exit__": { + "name": "__exit__", + "owner": "build123d.build_common.LocationList", + "category": "context_lifecycle", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 966, + "signature": "(self, exception_type, exception_value, traceback)" + }, + "build123d.build_common.LocationList.locations": { + "name": "locations", + "owner": "build123d.build_common.LocationList", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_common.py", + "source_line": 930, + "signature": "(self) -> 'list[Location]'" + }, + "build123d.build_line.BuildLine.face": { + "name": "face", + "owner": "build123d.build_line.BuildLine", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_line.py", + "source_line": 109, + "signature": "(self, *args)" + }, + "build123d.build_line.BuildLine.faces": { + "name": "faces", + "owner": "build123d.build_line.BuildLine", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_line.py", + "source_line": 105, + "signature": "(self, *args)" + }, + "build123d.build_line.BuildLine.line": { + "name": "line", + "owner": "build123d.build_line.BuildLine", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_line.py", + "source_line": 80, + "signature": "(self) -> 'Curve | None'" + }, + "build123d.build_line.BuildLine.line_local": { + "name": "line_local", + "owner": "build123d.build_line.BuildLine", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_line.py", + "source_line": 90, + "signature": "(self) -> 'Curve | None'" + }, + "build123d.build_line.BuildLine.solid": { + "name": "solid", + "owner": "build123d.build_line.BuildLine", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_line.py", + "source_line": 117, + "signature": "(self, *args)" + }, + "build123d.build_line.BuildLine.solids": { + "name": "solids", + "owner": "build123d.build_line.BuildLine", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_line.py", + "source_line": 113, + "signature": "(self, *args)" + }, + "build123d.build_part.BuildPart.location": { + "name": "location", + "owner": "build123d.build_part.BuildPart", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_part.py", + "source_line": 106, + "signature": "(self) -> 'Location'" + }, + "build123d.build_part.BuildPart.part": { + "name": "part", + "owner": "build123d.build_part.BuildPart", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_part.py", + "source_line": 76, + "signature": "(self) -> 'Part | None'" + }, + "build123d.build_part.BuildPart.part_local": { + "name": "part_local", + "owner": "build123d.build_part.BuildPart", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_part.py", + "source_line": 86, + "signature": "(self) -> 'Part | None'" + }, + "build123d.build_part.BuildPart.pending_edges_as_wire": { + "name": "pending_edges_as_wire", + "owner": "build123d.build_part.BuildPart", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_part.py", + "source_line": 101, + "signature": "(self) -> 'Wire'" + }, + "build123d.build_sketch.BuildSketch.consolidate_edges": { + "name": "consolidate_edges", + "owner": "build123d.build_sketch.BuildSketch", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_sketch.py", + "source_line": 110, + "signature": "(self) -> 'Wire | list[Wire]'" + }, + "build123d.build_sketch.BuildSketch.sketch": { + "name": "sketch", + "owner": "build123d.build_sketch.BuildSketch", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_sketch.py", + "source_line": 97, + "signature": "(self)" + }, + "build123d.build_sketch.BuildSketch.sketch_local": { + "name": "sketch_local", + "owner": "build123d.build_sketch.BuildSketch", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/build_sketch.py", + "source_line": 77, + "signature": "(self) -> 'Sketch | None'" + }, + "build123d.build_sketch.BuildSketch.solid": { + "name": "solid", + "owner": "build123d.build_sketch.BuildSketch", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_sketch.py", + "source_line": 106, + "signature": "(self, *args)" + }, + "build123d.build_sketch.BuildSketch.solids": { + "name": "solids", + "owner": "build123d.build_sketch.BuildSketch", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/build_sketch.py", + "source_line": 102, + "signature": "(self, *args)" + }, + "build123d.topology.composite.Curve.__add__": { + "name": "__add__", + "owner": "build123d.topology.composite.Curve", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 682, + "signature": "(self, other: 'None | Shape | Iterable[Shape]') -> 'Edge | Wire | Curve | Self'" + }, + "build123d.topology.composite.Compound.__and__": { + "name": "__and__", + "owner": "build123d.topology.composite.Compound", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 544, + "signature": "(self, other: 'Shape | Iterable[Shape]') -> 'Compound'" + }, + "build123d.topology.composite.Curve.__matmul__": { + "name": "__matmul__", + "owner": "build123d.topology.composite.Curve", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 968, + "signature": "(self, position: 'float') -> 'Vector'" + }, + "build123d.topology.composite.Curve.__mod__": { + "name": "__mod__", + "owner": "build123d.topology.composite.Curve", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 972, + "signature": "(self, position: 'float') -> 'Vector'" + }, + "build123d.topology.composite.Compound.__sub__": { + "name": "__sub__", + "owner": "build123d.topology.composite.Compound", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 594, + "signature": "(self, other: 'None | Shape | Iterable[Shape]') -> 'Compound'" + }, + "build123d.topology.composite.Curve.__xor__": { + "name": "__xor__", + "owner": "build123d.topology.composite.Curve", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 976, + "signature": "(self, position: 'float') -> 'Location'" + }, + "build123d.topology.composite.Compound.center": { + "name": "center", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 603, + "signature": "(self, center_of: 'CenterOf' = ) -> 'Vector'" + }, + "build123d.topology.composite.Compound.compound": { + "name": "compound", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 632, + "signature": "(self) -> 'Compound'" + }, + "build123d.topology.composite.Compound.compounds": { + "name": "compounds", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 640, + "signature": "(self) -> 'ShapeList[Compound]'" + }, + "build123d.topology.composite.Compound.do_children_intersect": { + "name": "do_children_intersect", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 652, + "signature": "(self, include_parent: 'bool' = False, tolerance: 'float' = 1e-05) -> 'tuple[bool, tuple[Shape | None, Shape | None], float]'" + }, + "build123d.topology.composite.Compound.extrude": { + "name": "extrude", + "owner": "build123d.topology.composite.Compound", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 212, + "signature": "(cls, obj: 'Shell', direction: 'VectorLike') -> 'Compound'" + }, + "build123d.topology.composite.Compound.get_type": { + "name": "get_type", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 703, + "signature": "(self, obj_type: 'type[Vertex] | type[Edge] | type[Face] | type[Shell] | type[Solid] | type[Wire]') -> 'list[Vertex | Edge | Face | Shell | Solid | Wire]'" + }, + "build123d.topology.composite.Compound.make_text": { + "name": "make_text", + "owner": "build123d.topology.composite.Compound", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 266, + "signature": "(cls, txt: 'str', font_size: 'float', font: 'str' = 'Arial', font_path: 'PathLike[str] | str | None' = None, font_style: 'FontStyle' = , text_align: 'tuple[TextAlign, TextAlign]' = (, ), align: 'Align | tuple[Align, Align] | None' = None, position_on_path: 'float' = 0.0, text_path: 'Edge | Wire | None' = None, single_line_width: 'float' = 0.0) -> 'Compound'" + }, + "build123d.topology.composite.Compound.make_triad": { + "name": "make_triad", + "owner": "build123d.topology.composite.Compound", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 437, + "signature": "(cls, axes_scale: 'float') -> 'Compound'" + }, + "build123d.topology.composite.Compound.mass": { + "name": "mass", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 190, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.composite.Compound.project_to_viewport": { + "name": "project_to_viewport", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 833, + "signature": "(self, viewport_origin: 'VectorLike', viewport_up: 'VectorLike' = (0, 0, 1), look_at: 'VectorLike | None' = None, focus: 'float | None' = None) -> 'tuple[ShapeList[Edge], ShapeList[Edge]]'" + }, + "build123d.topology.composite.Compound.resolve_font": { + "name": "resolve_font", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 230, + "signature": "(font: 'str' = 'Arial', font_path: 'PathLike[str] | str | None' = None, font_style: 'FontStyle' = ) -> 'tuple[str, str, Font_SystemFont]'" + }, + "build123d.topology.composite.Compound.touch": { + "name": "touch", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 808, + "signature": "(self, other: 'Shape', tolerance: 'float' = 1e-06) -> 'ShapeList[Vertex | Edge | Face]'" + }, + "build123d.topology.composite.Compound.unwrap": { + "name": "unwrap", + "owner": "build123d.topology.composite.Compound", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 860, + "signature": "(self, fully: 'bool' = True) -> 'Self | Shape'" + }, + "build123d.topology.composite.Compound.volume": { + "name": "volume", + "owner": "build123d.topology.composite.Compound", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 184, + "signature": "(self) -> 'float'" + }, + "build123d.topology.composite.Curve.wires": { + "name": "wires", + "owner": "build123d.topology.composite.Curve", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 980, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Wire]'" + }, + "build123d.topology.one_d.Edge.arc_center": { + "name": "arc_center", + "owner": "build123d.topology.one_d.Edge", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1684, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.one_d.Edge.close": { + "name": "close", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2744, + "signature": "(self) -> 'Edge | Wire'" + }, + "build123d.topology.one_d.Edge.distribute_locations": { + "name": "distribute_locations", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2753, + "signature": "(self: 'Wire | Edge', count: 'int', start: 'float' = 0.0, stop: 'float' = 1.0, positions_only: 'bool' = False) -> 'list[Location]'" + }, + "build123d.topology.one_d.Edge.extrude": { + "name": "extrude", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1702, + "signature": "(cls, obj: 'Vertex', direction: 'VectorLike') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.find_intersection_points": { + "name": "find_intersection_points", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2836, + "signature": "(self, other: 'Axis | Edge | None' = None, tolerance: 'float' = 1e-06) -> 'ShapeList[Vector]'" + }, + "build123d.topology.one_d.Edge.find_tangent": { + "name": "find_tangent", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2920, + "signature": "(self, angle: 'float') -> 'list[float]'" + }, + "build123d.topology.one_d.Edge.geom_adaptor": { + "name": "geom_adaptor", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2980, + "signature": "(self) -> 'BRepAdaptor_Curve'" + }, + "build123d.topology.one_d.Edge.geom_equal": { + "name": "geom_equal", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2986, + "signature": "(self, other: 'Edge', tol: 'float' = 1e-06, num_interpolation_points: 'int' = 5) -> 'bool'" + }, + "build123d.topology.one_d.Edge.is_infinite": { + "name": "is_infinite", + "owner": "build123d.topology.one_d.Edge", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3497, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.one_d.Edge.make_bezier": { + "name": "make_bezier", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1722, + "signature": "(cls, *cntl_pnts: 'VectorLike', weights: 'list[float] | None' = None) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_bspline": { + "name": "make_bspline", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2566, + "signature": "(cls, control_points: 'Iterable[VectorLike]', knots: 'Iterable[float]', degree: 'int', weights: 'Iterable[float] | None' = None, periodic: 'bool' = False) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_circle": { + "name": "make_circle", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1771, + "signature": "(cls, radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), start_angle: 'float' = 360.0, end_angle: 'float' = 360, angular_direction: 'AngularDirection' = ) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_constrained_arcs": { + "name": "make_constrained_arcs", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 1942, + "signature": "(cls, *args, sagitta: 'Sagitta' = , **kwargs) -> 'ShapeList[Edge]'" + }, + "build123d.topology.one_d.Edge.make_constrained_lines": { + "name": "make_constrained_lines", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2119, + "signature": "(cls, *args, **kwargs) -> 'ShapeList[Edge]'" + }, + "build123d.topology.one_d.Edge.make_ellipse": { + "name": "make_ellipse", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2204, + "signature": "(cls, x_radius: 'float', y_radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), start_angle: 'float' = 360.0, end_angle: 'float' = 360.0, angular_direction: 'AngularDirection' = ) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_helix": { + "name": "make_helix", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2361, + "signature": "(cls, pitch: 'float', height: 'float', radius: 'float', center: 'VectorLike' = (0, 0, 0), normal: 'VectorLike' = (0, 0, 1), angle: 'float' = 0.0, lefthand: 'bool' = False) -> 'Wire'" + }, + "build123d.topology.one_d.Edge.make_hyperbola": { + "name": "make_hyperbola", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2308, + "signature": "(cls, x_radius: 'float', y_radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), start_angle: 'float' = 360.0, end_angle: 'float' = 360.0, angular_direction: 'AngularDirection' = ) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_line": { + "name": "make_line", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2425, + "signature": "(cls, point1: 'VectorLike', point2: 'VectorLike') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_mid_way": { + "name": "make_mid_way", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2443, + "signature": "(cls, first: 'Edge', second: 'Edge', middle: 'float' = 0.5) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_parabola": { + "name": "make_parabola", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2271, + "signature": "(cls, focal_length: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), start_angle: 'float' = 0.0, end_angle: 'float' = 90.0, angular_direction: 'AngularDirection' = ) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_spline": { + "name": "make_spline", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2468, + "signature": "(cls, points: 'list[VectorLike]', tangents: 'list[VectorLike] | None' = None, periodic: 'bool' = False, parameters: 'list[float] | None' = None, scale: 'bool' = True, tol: 'float' = 1e-06) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_spline_approx": { + "name": "make_spline_approx", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2645, + "signature": "(cls, points: 'list[VectorLike]', tol: 'float' = 0.001, smoothing: 'tuple[float, float, float] | None' = None, min_deg: 'int' = 1, max_deg: 'int' = 6) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_tangent_arc": { + "name": "make_tangent_arc", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2698, + "signature": "(cls, start: 'VectorLike', tangent: 'VectorLike', end: 'VectorLike') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.make_three_point_arc": { + "name": "make_three_point_arc", + "owner": "build123d.topology.one_d.Edge", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 2720, + "signature": "(cls, point1: 'VectorLike', point2: 'VectorLike', point3: 'VectorLike') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.param_at": { + "name": "param_at", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3156, + "signature": "(self, position: 'float') -> 'float'" + }, + "build123d.topology.one_d.Edge.param_at_point": { + "name": "param_at_point", + "owner": "build123d.topology.one_d.Edge", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3185, + "signature": "(self, point: 'VectorLike') -> 'float'" + }, + "build123d.topology.one_d.Edge.project_to_shape": { + "name": "project_to_shape", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3315, + "signature": "(self, target_object: 'Shape', direction: 'VectorLike | None' = None, center: 'VectorLike | None' = None) -> 'ShapeList[Edge]'" + }, + "build123d.topology.one_d.Edge.reversed": { + "name": "reversed", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3349, + "signature": "(self, reconstruct: 'bool' = False) -> 'Edge'" + }, + "build123d.topology.one_d.Edge.trim": { + "name": "trim", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3380, + "signature": "(self, start: 'float | VectorLike', end: 'float | VectorLike') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.trim_infinite": { + "name": "trim_infinite", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3502, + "signature": "(self, half_length: 'float') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.trim_to_length": { + "name": "trim_to_length", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3428, + "signature": "(self, start: 'float | VectorLike', length: 'float') -> 'Edge'" + }, + "build123d.topology.one_d.Edge.trim_to_other": { + "name": "trim_to_other", + "owner": "build123d.topology.one_d.Edge", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3472, + "signature": "(self: 'Edge', other: 'Shape | Axis | Location | Plane | VectorLike') -> 'Edge | None'" + }, + "build123d.topology.one_d.Wire.chamfer_2d": { + "name": "chamfer_2d", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4041, + "signature": "(self, distance: 'float', distance2: 'float', vertices: 'Iterable[Vertex]', edge: 'Edge | None' = None) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.close": { + "name": "close", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4111, + "signature": "(self) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.combine": { + "name": "combine", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3764, + "signature": "(cls, wires: 'Iterable[Wire | Edge]', tol: 'float' = 1e-09) -> 'ShapeList[Wire]'" + }, + "build123d.topology.one_d.Wire.edges": { + "name": "edges", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4121, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Edge]'" + }, + "build123d.topology.one_d.Wire.extrude": { + "name": "extrude", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3795, + "signature": "(cls, obj: 'Shape', direction: 'VectorLike') -> 'Wire'" + }, + "build123d.topology.one_d.Wire.fillet_2d": { + "name": "fillet_2d", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4135, + "signature": "(self, radius: 'float', vertices: 'Iterable[Vertex]') -> 'Wire'" + }, + "build123d.topology.one_d.Wire.fix_degenerate_edges": { + "name": "fix_degenerate_edges", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4203, + "signature": "(self, precision: 'float') -> 'Wire'" + }, + "build123d.topology.one_d.Wire.geom_adaptor": { + "name": "geom_adaptor", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4224, + "signature": "(self) -> 'BRepAdaptor_CompCurve'" + }, + "build123d.topology.one_d.Wire.geom_equal": { + "name": "geom_equal", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4246, + "signature": "(self, other: 'Wire', tol: 'float' = 1e-06, num_interpolation_points: 'int' = 5) -> 'bool'" + }, + "build123d.topology.one_d.Wire.make_circle": { + "name": "make_circle", + "owner": "build123d.topology.one_d.Wire", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3800, + "signature": "(cls, radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.make_convex_hull": { + "name": "make_convex_hull", + "owner": "build123d.topology.one_d.Wire", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3816, + "signature": "(cls, edges: 'Iterable[Edge]', tolerance: 'float' = 0.001) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.make_ellipse": { + "name": "make_ellipse", + "owner": "build123d.topology.one_d.Wire", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3933, + "signature": "(cls, x_radius: 'float', y_radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), start_angle: 'float' = 360.0, end_angle: 'float' = 360.0, angular_direction: 'AngularDirection' = , closed: 'bool' = True) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.make_polygon": { + "name": "make_polygon", + "owner": "build123d.topology.one_d.Wire", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3973, + "signature": "(cls, vertices: 'Iterable[VectorLike]', close: 'bool' = True) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.make_rect": { + "name": "make_rect", + "owner": "build123d.topology.one_d.Wire", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 3996, + "signature": "(cls, width: 'float', height: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'Wire'" + }, + "build123d.topology.one_d.Wire.order_chamfer_edges": { + "name": "order_chamfer_edges", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4025, + "signature": "(reference_edge: 'Edge | None', edges: 'tuple[Edge, Edge]') -> 'tuple[Edge, Edge]'" + }, + "build123d.topology.one_d.Wire.order_edges": { + "name": "order_edges", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4231, + "signature": "(self) -> 'ShapeList[Edge]'" + }, + "build123d.topology.one_d.Wire.param_at": { + "name": "param_at", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4280, + "signature": "(self, position: 'float') -> 'float'" + }, + "build123d.topology.one_d.Wire.param_at_point": { + "name": "param_at_point", + "owner": "build123d.topology.one_d.Wire", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4314, + "signature": "(self, point: 'VectorLike') -> 'float'" + }, + "build123d.topology.one_d.Wire.project_to_shape": { + "name": "project_to_shape", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4482, + "signature": "(self, target_object: 'Shape', direction: 'VectorLike | None' = None, center: 'VectorLike | None' = None) -> 'ShapeList[Wire]'" + }, + "build123d.topology.one_d.Wire.stitch": { + "name": "stitch", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4593, + "signature": "(self, other: 'Wire') -> 'Wire'" + }, + "build123d.topology.one_d.Wire.trim": { + "name": "trim", + "owner": "build123d.topology.one_d.Wire", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/one_d.py", + "source_line": 4675, + "signature": "(self: 'Wire', start: 'float | VectorLike', end: 'float | VectorLike') -> 'Wire'" + }, + "build123d.objects_curve.Airfoil.camber_line": { + "name": "camber_line", + "owner": "build123d.objects_curve.Airfoil", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 234, + "signature": "(self) -> 'Edge'" + }, + "build123d.objects_curve.Airfoil.parse_naca4": { + "name": "parse_naca4", + "owner": "build123d.objects_curve.Airfoil", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/objects_curve.py", + "source_line": 143, + "signature": "(value: 'str | float') -> 'tuple[float, float, float]'" + }, + "build123d.topology.composite.Compound.__add__": { + "name": "__add__", + "owner": "build123d.topology.composite.Compound", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/composite.py", + "source_line": 490, + "signature": "(self, other: 'None | Shape | Iterable[Shape]') -> 'Compound | Wire'" + }, + "build123d.drafting.Draft.is_metric": { + "name": "is_metric", + "owner": "build123d.drafting.Draft", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/drafting.py", + "source_line": 207, + "signature": "(self) -> bool" + }, + "build123d.geometry.BoundBox.add": { + "name": "add", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1165, + "signature": "(self, obj: 'tuple[float, float, float] | Vector | BoundBox', tol: 'float | None' = None) -> 'BoundBox'" + }, + "build123d.geometry.BoundBox.center": { + "name": "center", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1161, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.BoundBox.contains": { + "name": "contains", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1316, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.contains_properly": { + "name": "contains_properly", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1326, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.covered_by": { + "name": "covered_by", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1312, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.covers": { + "name": "covers", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1297, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.diagonal": { + "name": "diagonal", + "owner": "build123d.geometry.BoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1147, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.BoundBox.disjoint": { + "name": "disjoint", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1348, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.find_outside_box_2d": { + "name": "find_outside_box_2d", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "typing_extensions.py", + "source_line": 1204, + "signature": "(bb1: 'BoundBox', bb2: 'BoundBox') -> 'BoundBox | None'" + }, + "build123d.geometry.BoundBox.from_topo_ds": { + "name": "from_topo_ds", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1243, + "signature": "(cls, shape: 'TopoDS_Shape', tolerance: 'float | None' = None, optimal: 'bool' = True) -> 'BoundBox'" + }, + "build123d.geometry.BoundBox.intersects": { + "name": "intersects", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1342, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.is_inside": { + "name": "is_inside", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "typing_extensions.py", + "source_line": 1366, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.measure": { + "name": "measure", + "owner": "build123d.geometry.BoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1137, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.BoundBox.overlaps": { + "name": "overlaps", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1358, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.to_align_offset": { + "name": "to_align_offset", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1375, + "signature": "(self, align: 'Align2D | Align3D') -> 'Vector'" + }, + "build123d.geometry.BoundBox.touches": { + "name": "touches", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1352, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.BoundBox.within": { + "name": "within", + "owner": "build123d.geometry.BoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1338, + "signature": "(self, other: 'BoundBox', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.OrientedBoundBox.center": { + "name": "center", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2369, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.OrientedBoundBox.corners": { + "name": "corners", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2250, + "signature": "(self) -> 'list[Vector]'" + }, + "build123d.geometry.OrientedBoundBox.diagonal": { + "name": "diagonal", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2286, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.OrientedBoundBox.is_completely_inside": { + "name": "is_completely_inside", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2380, + "signature": "(self, other: 'OrientedBoundBox') -> 'bool'" + }, + "build123d.geometry.OrientedBoundBox.is_outside": { + "name": "is_outside", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2400, + "signature": "(self, point: 'Vector') -> 'bool'" + }, + "build123d.geometry.OrientedBoundBox.location": { + "name": "location", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2297, + "signature": "(self) -> 'Location'" + }, + "build123d.geometry.OrientedBoundBox.plane": { + "name": "plane", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2307, + "signature": "(self) -> 'Plane'" + }, + "build123d.geometry.OrientedBoundBox.size": { + "name": "size", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2320, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.OrientedBoundBox.wrapped": { + "name": "wrapped", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2245, + "signature": "(self)" + }, + "build123d.geometry.OrientedBoundBox.x_direction": { + "name": "x_direction", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2333, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.OrientedBoundBox.y_direction": { + "name": "y_direction", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2345, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.OrientedBoundBox.z_direction": { + "name": "z_direction", + "owner": "build123d.geometry.OrientedBoundBox", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2357, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Location.__and__": { + "name": "__and__", + "owner": "build123d.geometry.Location", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2101, + "signature": "(self, other: 'Axis | Location | Plane | VectorLike | Shape') -> 'Vector | Location | None'" + }, + "build123d.geometry.Location.__mul__": { + "name": "__mul__", + "owner": "build123d.geometry.Location", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2031, + "signature": "(self, other: 'Any') -> 'Any'" + }, + "build123d.geometry.Location.__neg__": { + "name": "__neg__", + "owner": "build123d.geometry.Location", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2097, + "signature": "(self) -> 'Location'" + }, + "build123d.geometry.Location.center": { + "name": "center", + "owner": "build123d.geometry.Location", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2107, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Location.intersect": { + "name": "intersect", + "owner": "build123d.geometry.Location", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2191, + "signature": "(self, *args, **kwargs)" + }, + "build123d.geometry.Location.inverse": { + "name": "inverse", + "owner": "build123d.geometry.Location", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2001, + "signature": "(self) -> 'Location'" + }, + "build123d.geometry.Location.mirror": { + "name": "mirror", + "owner": "build123d.geometry.Location", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2111, + "signature": "(self, mirror_plane: 'Plane') -> 'Location'" + }, + "build123d.geometry.Location.orientation": { + "name": "orientation", + "owner": "build123d.geometry.Location", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1951, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Location.position": { + "name": "position", + "owner": "build123d.geometry.Location", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1928, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Location.wrapped": { + "name": "wrapped", + "owner": "build123d.geometry.Location", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1923, + "signature": "(self) -> 'TopLoc_Location'" + }, + "build123d.geometry.Location.x_axis": { + "name": "x_axis", + "owner": "build123d.geometry.Location", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1983, + "signature": "(self) -> 'Axis'" + }, + "build123d.geometry.Location.y_axis": { + "name": "y_axis", + "owner": "build123d.geometry.Location", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1989, + "signature": "(self) -> 'Axis'" + }, + "build123d.geometry.Location.z_axis": { + "name": "z_axis", + "owner": "build123d.geometry.Location", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1995, + "signature": "(self) -> 'Axis'" + }, + "build123d.topology.shape_core.ShapeList.__add__": { + "name": "__add__", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3320, + "signature": "(self, other: 'Shape | Iterable[Shape]') -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.__and__": { + "name": "__and__", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3342, + "signature": "(self, other: 'ShapeList') -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.__sub__": { + "name": "__sub__", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3394, + "signature": "(self, other: 'ShapeList') -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.center": { + "name": "center", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3421, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.shape_core.ShapeList.compound": { + "name": "compound", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3429, + "signature": "(self) -> 'Compound'" + }, + "build123d.topology.shape_core.ShapeList.compounds": { + "name": "compounds", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3437, + "signature": "(self) -> 'ShapeList[Compound]'" + }, + "build123d.topology.shape_core.ShapeList.edge": { + "name": "edge", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3441, + "signature": "(self) -> 'Edge'" + }, + "build123d.topology.shape_core.ShapeList.edges": { + "name": "edges", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3449, + "signature": "(self) -> 'ShapeList[Edge]'" + }, + "build123d.topology.shape_core.ShapeList.expand": { + "name": "expand", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3398, + "signature": "(self) -> 'ShapeList'" + }, + "build123d.topology.shape_core.ShapeList.face": { + "name": "face", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3453, + "signature": "(self) -> 'Face'" + }, + "build123d.topology.shape_core.ShapeList.faces": { + "name": "faces", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3461, + "signature": "(self) -> 'ShapeList[Face]'" + }, + "build123d.topology.shape_core.ShapeList.filter_by": { + "name": "filter_by", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3465, + "signature": "(self, filter_by: 'Callable[[T], bool] | Axis | Plane | GeomType | Convexity | property', reverse: 'bool' = False, tolerance: 'float' = 1e-05) -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.filter_by_position": { + "name": "filter_by_position", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3610, + "signature": "(self, axis: 'Axis', minimum: 'float', maximum: 'float', inclusive: 'tuple[bool, bool]' = (True, True)) -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.first": { + "name": "first", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3308, + "signature": "(self) -> 'T'" + }, + "build123d.topology.shape_core.ShapeList.group_by": { + "name": "group_by", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3661, + "signature": "(self, group_by: 'Callable[[T], K] | Axis | Edge | Wire | SortBy | property' = Axis((0, 0, 0), (0, 0, 1)), reverse: 'bool' = False, tol_digits: 'int' = 6) -> 'GroupBy[T, K]'" + }, + "build123d.topology.shape_core.ShapeList.last": { + "name": "last", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3313, + "signature": "(self) -> 'T'" + }, + "build123d.topology.shape_core.ShapeList.shell": { + "name": "shell", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3767, + "signature": "(self) -> 'Shell'" + }, + "build123d.topology.shape_core.ShapeList.shells": { + "name": "shells", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3775, + "signature": "(self) -> 'ShapeList[Shell]'" + }, + "build123d.topology.shape_core.ShapeList.solid": { + "name": "solid", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3779, + "signature": "(self) -> 'Solid'" + }, + "build123d.topology.shape_core.ShapeList.solids": { + "name": "solids", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3787, + "signature": "(self) -> 'ShapeList[Solid]'" + }, + "build123d.topology.shape_core.ShapeList.sort_by": { + "name": "sort_by", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3791, + "signature": "(self, sort_by: 'Callable[[T], K] | Axis | Edge | Wire | SortBy | property' = Axis((0, 0, 0), (0, 0, 1)), reverse: 'bool' = False) -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.sort_by_distance": { + "name": "sort_by_distance", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3890, + "signature": "(self, other: 'Shape | VectorLike', reverse: 'bool' = False) -> 'ShapeList[T]'" + }, + "build123d.topology.shape_core.ShapeList.vertex": { + "name": "vertex", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3911, + "signature": "(self) -> 'Vertex'" + }, + "build123d.topology.shape_core.ShapeList.vertices": { + "name": "vertices", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3919, + "signature": "(self) -> 'ShapeList[Vertex]'" + }, + "build123d.topology.shape_core.ShapeList.wire": { + "name": "wire", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3923, + "signature": "(self) -> 'Wire'" + }, + "build123d.topology.shape_core.ShapeList.wires": { + "name": "wires", + "owner": "build123d.topology.shape_core.ShapeList", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3931, + "signature": "(self) -> 'ShapeList[Wire]'" + }, + "build123d.geometry.Axis.__and__": { + "name": "__and__", + "owner": "build123d.geometry.Axis", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 950, + "signature": "(self, other: 'Axis | Location | Plane | VectorLike | Shape') -> 'Vector | Location | Axis | None'" + }, + "build123d.geometry.Axis.__neg__": { + "name": "__neg__", + "owner": "build123d.geometry.Axis", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 946, + "signature": "(self) -> 'Axis'" + }, + "build123d.geometry.Axis.angle_between": { + "name": "angle_between", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 928, + "signature": "(self, other: 'Axis') -> 'float'" + }, + "build123d.geometry.Axis.direction": { + "name": "direction", + "owner": "build123d.geometry.Axis", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 757, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Axis.intersect": { + "name": "intersect", + "owner": "build123d.geometry.Axis", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1012, + "signature": "(self, *args, **kwargs)" + }, + "build123d.geometry.Axis.is_coaxial": { + "name": "is_coaxial", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 819, + "signature": "(self, other: 'Axis', angular_tolerance: 'float' = 1e-05, linear_tolerance: 'float' = 1e-05) -> 'bool'" + }, + "build123d.geometry.Axis.is_normal": { + "name": "is_normal", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 842, + "signature": "(self, other: 'Axis', angular_tolerance: 'float' = 1e-05) -> 'bool'" + }, + "build123d.geometry.Axis.is_opposite": { + "name": "is_opposite", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 857, + "signature": "(self, other: 'Axis', angular_tolerance: 'float' = 1e-05) -> 'bool'" + }, + "build123d.geometry.Axis.is_parallel": { + "name": "is_parallel", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 873, + "signature": "(self, other: 'Axis', angular_tolerance: 'float' = 1e-05) -> 'bool'" + }, + "build123d.geometry.Axis.is_skew": { + "name": "is_skew", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 889, + "signature": "(self, other: 'Axis', tolerance: 'float' = 1e-05) -> 'bool'" + }, + "build123d.geometry.Axis.located": { + "name": "located", + "owner": "build123d.geometry.Axis", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 812, + "signature": "(self, new_location: 'Location')" + }, + "build123d.geometry.Axis.location": { + "name": "location", + "owner": "build123d.geometry.Axis", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 767, + "signature": "(self) -> 'Location'" + }, + "build123d.geometry.Axis.position": { + "name": "position", + "owner": "build123d.geometry.Axis", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 747, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Axis.reverse": { + "name": "reverse", + "owner": "build123d.geometry.Axis", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 942, + "signature": "(self) -> 'Axis'" + }, + "build123d.geometry.Axis.wrapped": { + "name": "wrapped", + "owner": "build123d.geometry.Axis", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 742, + "signature": "(self)" + }, + "build123d.geometry.Color.categorical_set": { + "name": "categorical_set", + "owner": "build123d.geometry.Color", + "category": "query_or_utility", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1569, + "signature": "(cls, color_count: 'int', starting_hue: 'ColorLike | float' = 0.0, alpha: 'float | Iterable[float]' = 1.0) -> 'list[Color]'" + }, + "build123d.geometry.Vector.X": { + "name": "X", + "owner": "build123d.geometry.Vector", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 260, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.Vector.Y": { + "name": "Y", + "owner": "build123d.geometry.Vector", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 270, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.Vector.Z": { + "name": "Z", + "owner": "build123d.geometry.Vector", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 280, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.Vector.__add__": { + "name": "__add__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 334, + "signature": "(self, vec: 'VectorLike') -> 'Vector'" + }, + "build123d.geometry.Vector.__and__": { + "name": "__and__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 450, + "signature": "(self, other: 'Axis | Location | Plane | VectorLike | Shape')" + }, + "build123d.geometry.Vector.__mul__": { + "name": "__mul__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 347, + "signature": "(self, scale: 'float') -> 'Vector'" + }, + "build123d.geometry.Vector.__neg__": { + "name": "__neg__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 442, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Vector.__radd__": { + "name": "__radd__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 338, + "signature": "(self, vec: 'Vector') -> 'Vector'" + }, + "build123d.geometry.Vector.__rmul__": { + "name": "__rmul__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 355, + "signature": "(self, scale: 'float') -> 'Vector'" + }, + "build123d.geometry.Vector.__sub__": { + "name": "__sub__", + "owner": "build123d.geometry.Vector", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 319, + "signature": "(self, vec: 'VectorLike') -> 'Vector'" + }, + "build123d.geometry.Vector.add": { + "name": "add", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 323, + "signature": "(self, vec: 'VectorLike') -> 'Vector'" + }, + "build123d.geometry.Vector.center": { + "name": "center", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 367, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Vector.cross": { + "name": "cross", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 300, + "signature": "(self, vec: 'Vector') -> 'Vector'" + }, + "build123d.geometry.Vector.distance_to_plane": { + "name": "distance_to_plane", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 417, + "signature": "(self, plane: 'Plane') -> 'float'" + }, + "build123d.geometry.Vector.dot": { + "name": "dot", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 304, + "signature": "(self, vec: 'Vector') -> 'float'" + }, + "build123d.geometry.Vector.get_angle": { + "name": "get_angle", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 379, + "signature": "(self, vec: 'Vector') -> 'float'" + }, + "build123d.geometry.Vector.get_signed_angle": { + "name": "get_signed_angle", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 383, + "signature": "(self, vec: 'Vector', normal: 'Vector | None' = None) -> 'float'" + }, + "build123d.geometry.Vector.intersect": { + "name": "intersect", + "owner": "build123d.geometry.Vector", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 577, + "signature": "(self, *args, **kwargs)" + }, + "build123d.geometry.Vector.length": { + "name": "length", + "owner": "build123d.geometry.Vector", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 295, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.Vector.multiply": { + "name": "multiply", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 343, + "signature": "(self, scale: 'float') -> 'Vector'" + }, + "build123d.geometry.Vector.normalized": { + "name": "normalized", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 359, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Vector.project_to_line": { + "name": "project_to_line", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 402, + "signature": "(self, line: 'Vector') -> 'Vector'" + }, + "build123d.geometry.Vector.project_to_plane": { + "name": "project_to_plane", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 425, + "signature": "(self, plane: 'Plane') -> 'Vector'" + }, + "build123d.geometry.Vector.reverse": { + "name": "reverse", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 363, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Vector.rotate": { + "name": "rotate", + "owner": "build123d.geometry.Vector", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 543, + "signature": "(self, axis: 'Axis', angle: 'float') -> 'Vector'" + }, + "build123d.geometry.Vector.signed_distance_from_plane": { + "name": "signed_distance_from_plane", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 421, + "signature": "(self, plane: 'Plane') -> 'float'" + }, + "build123d.geometry.Vector.sub": { + "name": "sub", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 308, + "signature": "(self, vec: 'VectorLike') -> 'Vector'" + }, + "build123d.geometry.Vector.to_dir": { + "name": "to_dir", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 515, + "signature": "(self) -> 'gp_Dir'" + }, + "build123d.geometry.Vector.to_pnt": { + "name": "to_pnt", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 511, + "signature": "(self) -> 'gp_Pnt'" + }, + "build123d.geometry.Vector.transform": { + "name": "transform", + "owner": "build123d.geometry.Vector", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 519, + "signature": "(self, affine_transform: 'Matrix', is_direction: 'bool' = False) -> 'Vector'" + }, + "build123d.geometry.Vector.wrapped": { + "name": "wrapped", + "owner": "build123d.geometry.Vector", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 290, + "signature": "(self) -> 'gp_Vec'" + }, + "build123d.topology.zero_d.Vertex.X": { + "name": "X", + "owner": "build123d.topology.zero_d.Vertex", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 289, + "signature": "(self) -> 'float'" + }, + "build123d.topology.zero_d.Vertex.Y": { + "name": "Y", + "owner": "build123d.topology.zero_d.Vertex", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 294, + "signature": "(self) -> 'float'" + }, + "build123d.topology.zero_d.Vertex.Z": { + "name": "Z", + "owner": "build123d.topology.zero_d.Vertex", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 299, + "signature": "(self) -> 'float'" + }, + "build123d.topology.zero_d.Vertex.__add__": { + "name": "__add__", + "owner": "build123d.topology.zero_d.Vertex", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 350, + "signature": "(self, other: 'Vertex | Vector | tuple[float, float, float]') -> 'Vertex'" + }, + "build123d.topology.zero_d.Vertex.__and__": { + "name": "__and__", + "owner": "build123d.topology.zero_d.Vertex", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 385, + "signature": "(self, *args, **kwargs)" + }, + "build123d.topology.zero_d.Vertex.__sub__": { + "name": "__sub__", + "owner": "build123d.topology.zero_d.Vertex", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 403, + "signature": "(self, other: 'Vertex | Vector | tuple') -> 'Vertex'" + }, + "build123d.topology.zero_d.Vertex.center": { + "name": "center", + "owner": "build123d.topology.zero_d.Vertex", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 433, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.zero_d.Vertex.convexity": { + "name": "convexity", + "owner": "build123d.topology.zero_d.Vertex", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 163, + "signature": "(self) -> 'Convexity'" + }, + "build123d.topology.zero_d.Vertex.extrude": { + "name": "extrude", + "owner": "build123d.topology.zero_d.Vertex", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 306, + "signature": "(cls, obj: 'Shape', direction: 'VectorLike') -> 'Vertex'" + }, + "build123d.topology.zero_d.Vertex.mass": { + "name": "mass", + "owner": "build123d.topology.zero_d.Vertex", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 158, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.zero_d.Vertex.split": { + "name": "split", + "owner": "build123d.topology.zero_d.Vertex", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 437, + "signature": "(self, tool: 'TrimmingTool', keep: 'Keep' = )" + }, + "build123d.topology.zero_d.Vertex.transform_shape": { + "name": "transform_shape", + "owner": "build123d.topology.zero_d.Vertex", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 441, + "signature": "(self, t_matrix: 'Matrix') -> 'Vertex'" + }, + "build123d.topology.zero_d.Vertex.vertex": { + "name": "vertex", + "owner": "build123d.topology.zero_d.Vertex", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 456, + "signature": "(self) -> 'Vertex'" + }, + "build123d.topology.zero_d.Vertex.vertices": { + "name": "vertices", + "owner": "build123d.topology.zero_d.Vertex", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 460, + "signature": "(self, select: 'Select' = ) -> 'ShapeList[Vertex]'" + }, + "build123d.topology.zero_d.Vertex.volume": { + "name": "volume", + "owner": "build123d.topology.zero_d.Vertex", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/zero_d.py", + "source_line": 153, + "signature": "(self) -> 'float'" + }, + "build123d.topology.two_d.Face.area_without_holes": { + "name": "area_without_holes", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 914, + "signature": "(self) -> 'float'" + }, + "build123d.topology.two_d.Face.axes_of_symmetry": { + "name": "axes_of_symmetry", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 962, + "signature": "(self) -> 'list[Axis]'" + }, + "build123d.topology.two_d.Face.axis_of_rotation": { + "name": "axis_of_rotation", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 931, + "signature": "(self) -> 'None | Axis'" + }, + "build123d.topology.two_d.Face.center": { + "name": "center", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1952, + "signature": "(self, center_of: 'CenterOf' = ) -> 'Vector'" + }, + "build123d.topology.two_d.Face.center_location": { + "name": "center_location", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1091, + "signature": "(self) -> 'Location'" + }, + "build123d.topology.two_d.Face.chamfer_2d": { + "name": "chamfer_2d", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1985, + "signature": "(self, distance: 'float', distance2: 'float', vertices: 'Iterable[Vertex]', edge: 'Edge | None' = None) -> 'Face'" + }, + "build123d.topology.two_d.Face.convexity": { + "name": "convexity", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1126, + "signature": "(self) -> 'Convexity'" + }, + "build123d.topology.two_d.Face.extrude": { + "name": "extrude", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1328, + "signature": "(cls, obj: 'Edge', direction: 'VectorLike') -> 'Face'" + }, + "build123d.topology.two_d.Face.fillet_2d": { + "name": "fillet_2d", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2045, + "signature": "(self, radius: 'float', vertices: 'Iterable[Vertex]') -> 'Face'" + }, + "build123d.topology.two_d.Face.geom_adaptor": { + "name": "geom_adaptor", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2087, + "signature": "(self) -> 'Geom_Surface'" + }, + "build123d.topology.two_d.Face.geometry": { + "name": "geometry", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1097, + "signature": "(self) -> 'None | str'" + }, + "build123d.topology.two_d.Face.inner_wires": { + "name": "inner_wires", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2091, + "signature": "(self) -> 'ShapeList[Wire]'" + }, + "build123d.topology.two_d.Face.is_circular_concave": { + "name": "is_circular_concave", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1196, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.two_d.Face.is_circular_convex": { + "name": "is_circular_convex", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1187, + "signature": "(self) -> 'bool'" + }, + "build123d.topology.two_d.Face.is_coplanar": { + "name": "is_coplanar", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2099, + "signature": "(self, plane: 'Plane') -> 'bool'" + }, + "build123d.topology.two_d.Face.is_inside": { + "name": "is_inside", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2111, + "signature": "(self, point: 'VectorLike', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.topology.two_d.Face.is_planar": { + "name": "is_planar", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1205, + "signature": "(self) -> 'Plane | None'" + }, + "build123d.topology.two_d.Face.length": { + "name": "length", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1217, + "signature": "(self) -> 'None | float'" + }, + "build123d.topology.two_d.Face.location_at": { + "name": "location_at", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2148, + "signature": "(self, *args, **kwargs) -> 'Location'" + }, + "build123d.topology.two_d.Face.make_bezier_surface": { + "name": "make_bezier_surface", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1348, + "signature": "(cls, points: 'list[list[VectorLike]]', weights: 'list[list[float]] | None' = None) -> 'Face'" + }, + "build123d.topology.two_d.Face.make_gordon_surface": { + "name": "make_gordon_surface", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1397, + "signature": "(cls, profiles: 'Iterable[VectorLike | Edge]', guides: 'Iterable[VectorLike | Edge]', tolerance: 'float' = 0.0003) -> 'Face'" + }, + "build123d.topology.two_d.Face.make_holes": { + "name": "make_holes", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2239, + "signature": "(self, interior_wires: 'list[Wire]') -> 'Face'" + }, + "build123d.topology.two_d.Face.make_rect": { + "name": "make_rect", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1482, + "signature": "(cls, width: 'float', height: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'Face'" + }, + "build123d.topology.two_d.Face.make_surface": { + "name": "make_surface", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1555, + "signature": "(cls, exterior: 'Wire | Iterable[Edge]', surface_points: 'Iterable[VectorLike] | None' = None, interior_wires: 'Iterable[Wire] | None' = None) -> 'Face'" + }, + "build123d.topology.two_d.Face.make_surface_from_array_of_points": { + "name": "make_surface_from_array_of_points", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1647, + "signature": "(cls, points: 'list[list[VectorLike]]', tol: 'float' = 0.01, smoothing: 'tuple[float, float, float] | None' = None, min_deg: 'int' = 1, max_deg: 'int' = 3) -> 'Face'" + }, + "build123d.topology.two_d.Face.make_surface_from_curves": { + "name": "make_surface_from_curves", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1721, + "signature": "(cls, *args, **kwargs) -> 'Face'" + }, + "build123d.topology.two_d.Face.make_surface_patch": { + "name": "make_surface_patch", + "owner": "build123d.topology.two_d.Face", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1763, + "signature": "(cls, edge_face_constraints: 'Iterable[tuple[Edge, Face, ContinuityLevel]] | None' = None, edge_constraints: 'Iterable[Edge] | None' = None, point_constraints: 'Iterable[VectorLike] | None' = None) -> 'Face'" + }, + "build123d.topology.two_d.Face.mass": { + "name": "mass", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1310, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.two_d.Face.normal_at": { + "name": "normal_at", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2312, + "signature": "(self, *args, **kwargs) -> 'Vector'" + }, + "build123d.topology.two_d.Face.outer_wire": { + "name": "outer_wire", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2369, + "signature": "(self) -> 'Wire'" + }, + "build123d.topology.two_d.Face.position_at": { + "name": "position_at", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2375, + "signature": "(self, u: 'float', v: 'float') -> 'Vector'" + }, + "build123d.topology.two_d.Face.project_to_shape": { + "name": "project_to_shape", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2399, + "signature": "(self, target_object: 'Shape', direction: 'VectorLike') -> 'ShapeList[Face | Shell]'" + }, + "build123d.topology.two_d.Face.radii": { + "name": "radii", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1228, + "signature": "(self) -> 'None | tuple[float, float]'" + }, + "build123d.topology.two_d.Face.radius": { + "name": "radius", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1239, + "signature": "(self) -> 'None | float'" + }, + "build123d.topology.two_d.Face.revolve": { + "name": "revolve", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1835, + "signature": "(cls, profile: 'Edge', angle: 'float', axis: 'Axis') -> 'Face'" + }, + "build123d.topology.two_d.Face.seams": { + "name": "seams", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1248, + "signature": "(self: 'Face') -> 'ShapeList[Edge]'" + }, + "build123d.topology.two_d.Face.semi_angle": { + "name": "semi_angle", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1254, + "signature": "(self) -> 'None | float'" + }, + "build123d.topology.two_d.Face.sew_faces": { + "name": "sew_faces", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1863, + "signature": "(cls, faces: 'Iterable[Face]') -> 'list[ShapeList[Face]]'" + }, + "build123d.topology.two_d.Face.sweep": { + "name": "sweep", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1903, + "signature": "(cls, profile: 'Curve | Edge | Wire', path: 'Curve | Edge | Wire', transition=) -> 'Face'" + }, + "build123d.topology.two_d.Face.uv_face": { + "name": "uv_face", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1263, + "signature": "(self) -> 'Face'" + }, + "build123d.topology.two_d.Face.volume": { + "name": "volume", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1305, + "signature": "(self) -> 'float'" + }, + "build123d.topology.two_d.Face.width": { + "name": "width", + "owner": "build123d.topology.two_d.Face", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 1315, + "signature": "(self) -> 'None | float'" + }, + "build123d.topology.two_d.Face.wire": { + "name": "wire", + "owner": "build123d.topology.two_d.Face", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2484, + "signature": "(self) -> 'Wire'" + }, + "build123d.topology.two_d.Face.without_holes": { + "name": "without_holes", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2461, + "signature": "(self) -> 'Face'" + }, + "build123d.topology.two_d.Face.wrap": { + "name": "wrap", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2518, + "signature": "(self, planar_shape: 'T', surface_loc: 'Location', tolerance: 'float' = 0.001, extension_factor: 'float' = 0.1) -> 'T'" + }, + "build123d.topology.two_d.Face.wrap_faces": { + "name": "wrap_faces", + "owner": "build123d.topology.two_d.Face", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2577, + "signature": "(self, faces: 'Iterable[Face]', path: 'Wire | Edge', start: 'float' = 0.0) -> 'ShapeList[Face]'" + }, + "build123d.geometry.Matrix.inverse": { + "name": "inverse", + "owner": "build123d.geometry.Matrix", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2703, + "signature": "(self) -> 'Matrix'" + }, + "build123d.geometry.Matrix.multiply": { + "name": "multiply", + "owner": "build123d.geometry.Matrix", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2715, + "signature": "(self, other)" + }, + "build123d.geometry.Matrix.rotate": { + "name": "rotate", + "owner": "build123d.geometry.Matrix", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2697, + "signature": "(self, axis: 'Axis', angle: 'float')" + }, + "build123d.geometry.Matrix.transposed_list": { + "name": "transposed_list", + "owner": "build123d.geometry.Matrix", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2722, + "signature": "(self) -> 'Sequence[float]'" + }, + "build123d.topology.three_d.Solid.draft": { + "name": "draft", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1794, + "signature": "(self, faces: 'Iterable[Face]', neutral_plane: 'Plane', angle: 'float') -> 'Solid'" + }, + "build123d.topology.three_d.Solid.extrude": { + "name": "extrude", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1016, + "signature": "(cls, obj: 'Face', direction: 'VectorLike') -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "03_prismatic_solid", + "04_lines_and_arcs_profile", + "05_offset_cutouts", + "06_point_list_holes", + "07_polygon_holes", + "08_i_beam", + "11_grid_polygon_holes", + "12_spline_profile", + "15_mirrored_profile", + "16_mirrored_3d_parts", + "17_face_mirror", + "18_face_cutout", + "19_vertex_cutouts", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "25_offset_polygon_layers", + "27_split_plate", + "28_face_located_sphere_holes", + "29_occ_bottle", + "30_bezier_profile", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern", + "34_embossed_debossed_text", + "35_curved_slots", + "37_positioned_sketches", + "41_pillow_block", + "42_din_rail", + "43_lego", + "45_key_cap", + "48_circuit_board" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.extrude_linear_with_rotation": { + "name": "extrude_linear_with_rotation", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1034, + "signature": "(cls, section: 'Face | Wire', center: 'VectorLike', normal: 'VectorLike', angle: 'float', inner_wires: 'list[Wire] | None' = None) -> 'Solid'" + }, + "build123d.topology.three_d.Solid.extrude_taper": { + "name": "extrude_taper", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1128, + "signature": "(cls, profile: 'Face', direction: 'VectorLike', taper: 'float', flip_inner: 'bool' = True) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "45_key_cap" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.extrude_until": { + "name": "extrude_until", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1202, + "signature": "(cls, profile: 'Face', target: 'Compound | Solid', direction: 'VectorLike', until: 'Until' = ) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "36_extrude_until", + "45_key_cap" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.from_bounding_box": { + "name": "from_bounding_box", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1312, + "signature": "(cls, bbox: 'BoundBox | OrientedBoundBox') -> 'Solid'" + }, + "build123d.topology.three_d.Solid.make_box": { + "name": "make_box", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1320, + "signature": "(cls, length: 'float', width: 'float', height: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "01_rectangular_plate", + "02_plate_with_hole", + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "18_face_cutout", + "20_offset_plane_cylinder", + "22_angled_drill_holes", + "24_circle_rectangle_loft", + "26_thin_wall_box", + "27_split_plate", + "34_embossed_debossed_text", + "35_curved_slots", + "38_rotated_boxes", + "43_lego" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.make_cone": { + "name": "make_cone", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1348, + "signature": "(cls, base_radius: 'float', top_radius: 'float', height: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), angle: 'float' = 360) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "13_countersink_counterbore", + "49_holes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.make_cylinder": { + "name": "make_cylinder", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1383, + "signature": "(cls, radius: 'float', height: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), angle: 'float' = 360) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "02_plate_with_hole", + "10_filleted_hole", + "11_grid_polygon_holes", + "13_countersink_counterbore", + "28_face_located_sphere_holes", + "41_pillow_block", + "43_lego", + "49_holes" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.make_loft": { + "name": "make_loft", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1415, + "signature": "(cls, objs: 'Iterable[Vertex | Wire]', ruled: 'bool' = False) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "24_circle_rectangle_loft", + "44_loft" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.make_sphere": { + "name": "make_sphere", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1435, + "signature": "(cls, radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), angle1: 'float' = -90, angle2: 'float' = 90, angle3: 'float' = 360) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "28_face_located_sphere_holes", + "45_key_cap" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.make_torus": { + "name": "make_torus", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1470, + "signature": "(cls, major_radius: 'float', minor_radius: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1)), start_angle: 'float' = 0, end_angle: 'float' = 360, major_angle: 'float' = 360) -> 'Solid'" + }, + "build123d.topology.three_d.Solid.make_wedge": { + "name": "make_wedge", + "owner": "build123d.topology.three_d.Solid", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1507, + "signature": "(cls, delta_x: 'float', delta_y: 'float', delta_z: 'float', min_x: 'float', min_z: 'float', max_x: 'float', max_z: 'float', plane: 'Plane' = Plane((0, 0, 0), (1, 0, 0), (0, 0, 1))) -> 'Solid'" + }, + "build123d.topology.three_d.Solid.mass": { + "name": "mass", + "owner": "build123d.topology.three_d.Solid", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 774, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.three_d.Solid.revolve": { + "name": "revolve", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1549, + "signature": "(cls, section: 'Face | Wire', angle: 'float', axis: 'Axis', inner_wires: 'list[Wire] | None' = None) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "23_revolved_profile", + "36_extrude_until", + "47_vase" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.sweep": { + "name": "sweep", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1586, + "signature": "(cls, section: 'Face | Wire', path: 'Wire | Edge', inner_wires: 'list[Wire] | None' = None, make_solid: 'bool' = True, is_frenet: 'bool' = False, mode: 'Vector | Wire | Edge | None' = None, transition: 'Transition' = ) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "14_swept_square_tube", + "39_pegboard_j_hook", + "50_spring" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.sweep_multi": { + "name": "sweep_multi", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "verified_sampled_usage", + "source_file": "build123d/topology/three_d.py", + "source_line": 1668, + "signature": "(cls, profiles: 'Iterable[Wire | Face]', path: 'Wire | Edge', make_solid: 'bool' = True, is_frenet: 'bool' = False, binormal: 'Vector | Wire | Edge | None' = None) -> 'Solid'", + "validation_evidence": { + "accepted_models": [ + "40_handle" + ], + "scope": "Captured member call in accepted models; other argument variants remain unverified." + } + }, + "build123d.topology.three_d.Solid.thicken": { + "name": "thicken", + "owner": "build123d.topology.three_d.Solid", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 1734, + "signature": "(cls, surface: 'Face | Shell', depth: 'float', normal_override: 'VectorLike | None' = None) -> 'Solid'" + }, + "build123d.topology.three_d.Solid.touch": { + "name": "touch", + "owner": "build123d.topology.three_d.Solid", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 780, + "signature": "(self, other: 'Shape', tolerance: 'float' = 1e-06, found_solids: 'ShapeList | None' = None) -> 'ShapeList[Vertex | Edge | Face]'" + }, + "build123d.topology.three_d.Solid.volume": { + "name": "volume", + "owner": "build123d.topology.three_d.Solid", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/three_d.py", + "source_line": 767, + "signature": "(self) -> 'float'" + }, + "build123d.topology.two_d.Shell.center": { + "name": "center", + "owner": "build123d.topology.two_d.Shell", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 3015, + "signature": "(self) -> 'Vector'" + }, + "build123d.topology.two_d.Shell.extrude": { + "name": "extrude", + "owner": "build123d.topology.two_d.Shell", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2917, + "signature": "(cls, obj: 'Wire', direction: 'VectorLike') -> 'Shell'" + }, + "build123d.topology.two_d.Shell.location_at": { + "name": "location_at", + "owner": "build123d.topology.two_d.Shell", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 3021, + "signature": "(self, surface_point: 'VectorLike', *, x_dir: 'VectorLike | None' = None) -> 'Location'" + }, + "build123d.topology.two_d.Shell.make_loft": { + "name": "make_loft", + "owner": "build123d.topology.two_d.Shell", + "category": "factory", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2935, + "signature": "(cls, objs: 'Iterable[Vertex | Wire]', ruled: 'bool' = False) -> 'Shell'" + }, + "build123d.topology.two_d.Shell.mass": { + "name": "mass", + "owner": "build123d.topology.two_d.Shell", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2911, + "signature": "(self, mass_unit: 'Unit' = , length_unit: 'Unit' = ) -> 'float'" + }, + "build123d.topology.two_d.Shell.revolve": { + "name": "revolve", + "owner": "build123d.topology.two_d.Shell", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2955, + "signature": "(cls, profile: 'Curve | Wire', angle: 'float', axis: 'Axis') -> 'Face'" + }, + "build123d.topology.two_d.Shell.sweep": { + "name": "sweep", + "owner": "build123d.topology.two_d.Shell", + "category": "feature", + "descriptor": "classmethod", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2981, + "signature": "(cls, profile: 'Curve | Edge | Wire', path: 'Curve | Edge | Wire', transition=) -> 'Shell'" + }, + "build123d.topology.two_d.Shell.volume": { + "name": "volume", + "owner": "build123d.topology.two_d.Shell", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/two_d.py", + "source_line": 2899, + "signature": "(self) -> 'float'" + }, + "build123d.geometry.Plane.__and__": { + "name": "__and__", + "owner": "build123d.geometry.Plane", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3215, + "signature": "(self: 'Plane', other: 'Axis | Location | Plane | VectorLike | Shape')" + }, + "build123d.geometry.Plane.__mul__": { + "name": "__mul__", + "owner": "build123d.geometry.Plane", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3187, + "signature": "(self, other: 'Location | Plane | Iterable[Location | Plane]') -> 'Location | list[Location]'" + }, + "build123d.geometry.Plane.__neg__": { + "name": "__neg__", + "owner": "build123d.geometry.Plane", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3177, + "signature": "(self) -> 'Plane'" + }, + "build123d.geometry.Plane.__rmul__": { + "name": "__rmul__", + "owner": "build123d.geometry.Plane", + "category": "algebra_operator", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3210, + "signature": "(self, other: 'Location | Plane | Iterable[Location | Plane]') -> 'Plane | list[Plane]'" + }, + "build123d.geometry.Plane.contains": { + "name": "contains", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3511, + "signature": "(self, obj: 'VectorLike | Axis', tolerance: 'float' = 1e-06) -> 'bool'" + }, + "build123d.geometry.Plane.forward_transform": { + "name": "forward_transform", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3382, + "signature": "(self)" + }, + "build123d.geometry.Plane.from_local_coords": { + "name": "from_local_coords", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3489, + "signature": "(self, obj: 'tuple | Vector | Any | BoundBox')" + }, + "build123d.geometry.Plane.get_topods_face_normal": { + "name": "get_topods_face_normal", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 2905, + "signature": "(face: 'TopoDS_Face') -> 'Vector'" + }, + "build123d.geometry.Plane.intersect": { + "name": "intersect", + "owner": "build123d.geometry.Plane", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3590, + "signature": "(self, *args, **kwargs)" + }, + "build123d.geometry.Plane.location": { + "name": "location", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3400, + "signature": "(self) -> 'Location'" + }, + "build123d.geometry.Plane.location_between": { + "name": "location_between", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3502, + "signature": "(self, other: 'Plane') -> 'Location'" + }, + "build123d.geometry.Plane.move": { + "name": "move", + "owner": "build123d.geometry.Plane", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3370, + "signature": "(self, loc: 'Location | Plane') -> 'Plane'" + }, + "build123d.geometry.Plane.moved": { + "name": "moved", + "owner": "build123d.geometry.Plane", + "category": "transform", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3357, + "signature": "(self, loc: 'Location | Plane') -> 'Plane'" + }, + "build123d.geometry.Plane.offset": { + "name": "offset", + "owner": "build123d.geometry.Plane", + "category": "feature", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3149, + "signature": "(self, amount: 'float') -> 'Plane'" + }, + "build123d.geometry.Plane.origin": { + "name": "origin", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3244, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Plane.reverse": { + "name": "reverse", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3240, + "signature": "(self) -> 'Plane'" + }, + "build123d.geometry.Plane.reverse_transform": { + "name": "reverse_transform", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3391, + "signature": "(self)" + }, + "build123d.geometry.Plane.rotated": { + "name": "rotated", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3320, + "signature": "(self, rotation: 'VectorLike' = (0, 0, 0), ordering: 'Extrinsic | Intrinsic | None' = None) -> 'Plane'" + }, + "build123d.geometry.Plane.shift_origin": { + "name": "shift_origin", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3283, + "signature": "(self, locator: 'Axis | VectorLike | Vertex') -> 'Plane'" + }, + "build123d.geometry.Plane.to_gp_ax2": { + "name": "to_gp_ax2", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3409, + "signature": "(self) -> 'gp_Ax2'" + }, + "build123d.geometry.Plane.to_gp_ax3": { + "name": "to_gp_ax3", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3405, + "signature": "(self) -> 'gp_Ax3'" + }, + "build123d.geometry.Plane.to_local_coords": { + "name": "to_local_coords", + "owner": "build123d.geometry.Plane", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3476, + "signature": "(self, obj: 'VectorLike | Any | BoundBox')" + }, + "build123d.geometry.Plane.wrapped": { + "name": "wrapped", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3134, + "signature": "(self) -> 'gp_Pln'" + }, + "build123d.geometry.Plane.x_dir": { + "name": "x_dir", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3259, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Plane.y_dir": { + "name": "y_dir", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3271, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.Plane.z_dir": { + "name": "z_dir", + "owner": "build123d.geometry.Plane", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 3254, + "signature": "(self) -> 'Vector'" + }, + "build123d.geometry.GeomEncoder.default": { + "name": "default", + "owner": "build123d.geometry.GeomEncoder", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1714, + "signature": "(self, o)" + }, + "build123d.geometry.GeomEncoder.geometry_hook": { + "name": "geometry_hook", + "owner": "build123d.geometry.GeomEncoder", + "category": "query_or_utility", + "descriptor": "staticmethod", + "conversion_status": "unverified", + "source_file": "build123d/geometry.py", + "source_line": 1730, + "signature": "(json_dict)" + }, + "build123d.topology.shape_core.Joint.connect_to": { + "name": "connect_to", + "owner": "build123d.topology.shape_core.Joint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3986, + "signature": "(self, *args, **kwargs)" + }, + "build123d.topology.shape_core.Joint.location": { + "name": "location", + "owner": "build123d.topology.shape_core.Joint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3974, + "signature": "(self) -> 'Location'" + }, + "build123d.topology.shape_core.Joint.relative_to": { + "name": "relative_to", + "owner": "build123d.topology.shape_core.Joint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3990, + "signature": "(self, *args, **kwargs) -> 'Location'" + }, + "build123d.topology.shape_core.Joint.symbol": { + "name": "symbol", + "owner": "build123d.topology.shape_core.Joint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/topology/shape_core.py", + "source_line": 3979, + "signature": "(self) -> 'Compound'" + }, + "build123d.joints.RigidJoint.connect_to": { + "name": "connect_to", + "owner": "build123d.joints.RigidJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 130, + "signature": "(self, other: 'Joint', **kwargs)" + }, + "build123d.joints.RigidJoint.location": { + "name": "location", + "owner": "build123d.joints.RigidJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 68, + "signature": "(self) -> 'Location'" + }, + "build123d.joints.RigidJoint.relative_to": { + "name": "relative_to", + "owner": "build123d.joints.RigidJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 169, + "signature": "(self, other: 'Joint', **kwargs) -> 'Location'" + }, + "build123d.joints.RigidJoint.symbol": { + "name": "symbol", + "owner": "build123d.joints.RigidJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 73, + "signature": "(self) -> 'Compound'" + }, + "build123d.joints.RevoluteJoint.connect_to": { + "name": "connect_to", + "owner": "build123d.joints.RevoluteJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 291, + "signature": "(self, other: 'RigidJoint', *, angle: 'float | None' = None)" + }, + "build123d.joints.RevoluteJoint.location": { + "name": "location", + "owner": "build123d.joints.RevoluteJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 242, + "signature": "(self) -> 'Location'" + }, + "build123d.joints.RevoluteJoint.relative_to": { + "name": "relative_to", + "owner": "build123d.joints.RevoluteJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 304, + "signature": "(self, other: 'RigidJoint', *, angle: 'float | None' = None)" + }, + "build123d.joints.RevoluteJoint.symbol": { + "name": "symbol", + "owner": "build123d.joints.RevoluteJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 247, + "signature": "(self) -> 'Compound'" + }, + "build123d.joints.LinearJoint.connect_to": { + "name": "connect_to", + "owner": "build123d.joints.LinearJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 423, + "signature": "(self, other: 'Joint', **kwargs)" + }, + "build123d.joints.LinearJoint.location": { + "name": "location", + "owner": "build123d.joints.LinearJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 367, + "signature": "(self) -> 'Location'" + }, + "build123d.joints.LinearJoint.relative_to": { + "name": "relative_to", + "owner": "build123d.joints.LinearJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 452, + "signature": "(self, other, **kwargs)" + }, + "build123d.joints.LinearJoint.symbol": { + "name": "symbol", + "owner": "build123d.joints.LinearJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 372, + "signature": "(self) -> 'Compound'" + }, + "build123d.joints.CylindricalJoint.connect_to": { + "name": "connect_to", + "owner": "build123d.joints.CylindricalJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 601, + "signature": "(self, other: 'RigidJoint', *, position: 'float | None' = None, angle: 'float | None' = None)" + }, + "build123d.joints.CylindricalJoint.location": { + "name": "location", + "owner": "build123d.joints.CylindricalJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 547, + "signature": "(self) -> 'Location'" + }, + "build123d.joints.CylindricalJoint.relative_to": { + "name": "relative_to", + "owner": "build123d.joints.CylindricalJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 622, + "signature": "(self, other: 'RigidJoint', *, position: 'float | None' = None, angle: 'float | None' = None)" + }, + "build123d.joints.CylindricalJoint.symbol": { + "name": "symbol", + "owner": "build123d.joints.CylindricalJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 552, + "signature": "(self) -> 'Compound'" + }, + "build123d.joints.BallJoint.connect_to": { + "name": "connect_to", + "owner": "build123d.joints.BallJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 753, + "signature": "(self, other: 'RigidJoint', *, angles: 'RotationLike | None' = None)" + }, + "build123d.joints.BallJoint.location": { + "name": "location", + "owner": "build123d.joints.BallJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 695, + "signature": "(self) -> 'Location'" + }, + "build123d.joints.BallJoint.relative_to": { + "name": "relative_to", + "owner": "build123d.joints.BallJoint", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 767, + "signature": "(self, other: 'RigidJoint', *, angles: 'RotationLike | None' = None)" + }, + "build123d.joints.BallJoint.symbol": { + "name": "symbol", + "owner": "build123d.joints.BallJoint", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/joints.py", + "source_line": 700, + "signature": "(self) -> 'Compound'" + }, + "build123d.text.FontManager.available_fonts": { + "name": "available_fonts", + "owner": "build123d.text.FontManager", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 111, + "signature": "(self) -> list[build123d.text.FontInfo]" + }, + "build123d.text.FontManager.check_font": { + "name": "check_font", + "owner": "build123d.text.FontManager", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 132, + "signature": "(self, path: str) -> OCP.OCP.Font.Font_SystemFont | None" + }, + "build123d.text.FontManager.find_font": { + "name": "find_font", + "owner": "build123d.text.FontManager", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 136, + "signature": "(self, name: str, style: build123d.build_enums.FontStyle) -> OCP.OCP.Font.Font_SystemFont" + }, + "build123d.text.FontManager.register_folder": { + "name": "register_folder", + "owner": "build123d.text.FontManager", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 173, + "signature": "(self, path: str, override: bool = False, single_stroke=False) -> list[str]" + }, + "build123d.text.FontManager.register_font": { + "name": "register_font", + "owner": "build123d.text.FontManager", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 140, + "signature": "(self, path: str, override: bool = False, single_stroke=False) -> list[str]" + }, + "build123d.text.FontManager.register_system_fonts": { + "name": "register_system_fonts", + "owner": "build123d.text.FontManager", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/text.py", + "source_line": 187, + "signature": "(self)" + }, + "build123d.exporters.ExportDXF.add_layer": { + "name": "add_layer", + "owner": "build123d.exporters.ExportDXF", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 544, + "signature": "(self, name: str, *, color: build123d.exporters.ColorIndex | None = None, line_weight: float | None = None, line_type: build123d.exporters.LineType | None = None) -> Self" + }, + "build123d.exporters.ExportDXF.add_shape": { + "name": "add_shape", + "owner": "build123d.exporters.ExportDXF", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 607, + "signature": "(self, shape: build123d.topology.shape_core.Shape | collections.abc.Iterable[build123d.topology.shape_core.Shape], layer: str = '') -> Self" + }, + "build123d.exporters.ExportDXF.write": { + "name": "write", + "owner": "build123d.exporters.ExportDXF", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 643, + "signature": "(self, file_name: os.PathLike | str | bytes | _io.BytesIO, ascii_format: bool = True)" + }, + "build123d.exporters.ExportSVG.add_layer": { + "name": "add_layer", + "owner": "build123d.exporters.ExportSVG", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 1028, + "signature": "(self, name: str, *, fill_color: str | tuple[str, float | int] | tuple[float | int, float | int, float | int] | tuple[float | int, float | int, float | int, float | int] | int | tuple[int, int] | build123d.geometry.Color | OCP.OCP.Quantity.Quantity_ColorRGBA | build123d.exporters.ColorIndex | ezdxf.colors.RGB | None | typing_extensions.sentinel = INHERIT_COLOR, line_color: str | tuple[str, float | int] | tuple[float | int, float | int, float | int] | tuple[float | int, float | int, float | int, float | int] | int | tuple[int, int] | build123d.geometry.Color | OCP.OCP.Quantity.Quantity_ColorRGBA | build123d.exporters.ColorIndex | ezdxf.colors.RGB | None | typing_extensions.sentinel = INHERIT_COLOR, line_weight: float = 0.09, line_type: build123d.exporters.LineType = ) -> Self" + }, + "build123d.exporters.ExportSVG.add_shape": { + "name": "add_shape", + "owner": "build123d.exporters.ExportSVG", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 1077, + "signature": "(self, shape: build123d.topology.shape_core.Shape | collections.abc.Iterable[build123d.topology.shape_core.Shape], layer: str = '', reverse_wires: bool = False)" + }, + "build123d.exporters.ExportSVG.write": { + "name": "write", + "owner": "build123d.exporters.ExportSVG", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/exporters.py", + "source_line": 1554, + "signature": "(self, path: os.PathLike | str | bytes | _io.BytesIO)" + }, + "build123d.mesher.Mesher.add_code_to_metadata": { + "name": "add_code_to_metadata", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 217, + "signature": "(self)" + }, + "build123d.mesher.Mesher.add_meta_data": { + "name": "add_meta_data", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 188, + "signature": "(self, name_space: str, name: str, value: str, metadata_type: str, must_preserve: bool)" + }, + "build123d.mesher.Mesher.add_shape": { + "name": "add_shape", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 369, + "signature": "(self, shape: build123d.topology.shape_core.Shape | collections.abc.Iterable[build123d.topology.shape_core.Shape], linear_deflection: float = 0.001, angular_deflection: float = 0.1, mesh_type: build123d.build_enums.MeshType = , part_number: str | None = None, uuid_value: uuid.UUID | None = None)" + }, + "build123d.mesher.Mesher.get_mesh_properties": { + "name": "get_mesh_properties", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 256, + "signature": "(self) -> list[dict]" + }, + "build123d.mesher.Mesher.get_meta_data": { + "name": "get_meta_data", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 233, + "signature": "(self) -> list[dict]" + }, + "build123d.mesher.Mesher.get_meta_data_by_key": { + "name": "get_meta_data_by_key", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 247, + "signature": "(self, name_space: str, name: str) -> dict" + }, + "build123d.mesher.Mesher.library_version": { + "name": "library_version", + "owner": "build123d.mesher.Mesher", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 182, + "signature": "(self) -> str" + }, + "build123d.mesher.Mesher.mesh_count": { + "name": "mesh_count", + "owner": "build123d.mesher.Mesher", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 176, + "signature": "(self) -> int" + }, + "build123d.mesher.Mesher.model_unit": { + "name": "model_unit", + "owner": "build123d.mesher.Mesher", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 161, + "signature": "(self) -> build123d.build_enums.Unit" + }, + "build123d.mesher.Mesher.read": { + "name": "read", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 516, + "signature": "(self, file_name: os.PathLike | str | bytes) -> list[build123d.topology.shape_core.Shape]" + }, + "build123d.mesher.Mesher.triangle_counts": { + "name": "triangle_counts", + "owner": "build123d.mesher.Mesher", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 166, + "signature": "(self) -> list[int]" + }, + "build123d.mesher.Mesher.vertex_counts": { + "name": "vertex_counts", + "owner": "build123d.mesher.Mesher", + "category": "property", + "descriptor": "property", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 171, + "signature": "(self) -> list[int]" + }, + "build123d.mesher.Mesher.write": { + "name": "write", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 560, + "signature": "(self, file_name: os.PathLike | str | bytes)" + }, + "build123d.mesher.Mesher.write_stream": { + "name": "write_stream", + "owner": "build123d.mesher.Mesher", + "category": "query_or_utility", + "descriptor": "method", + "conversion_status": "unverified", + "source_file": "build123d/mesher.py", + "source_line": 576, + "signature": "(self, stream: _io.BytesIO, file_type: Literal['3mf', 'stl'])" + } + }, + "class_members": { + "build123d.topology.shape_core.Shape": [ + "build123d.topology.shape_core.Shape.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.shape_core.Shape.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.one_d.Mixin1D": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Mixin1D.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.two_d.Mixin2D": [ + "build123d.topology.shape_core.Shape.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.two_d.Mixin2D.__neg__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.two_d.Mixin2D.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.two_d.Mixin2D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.two_d.Mixin2D.location_at", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.two_d.Mixin2D.offset", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.two_d.Mixin2D.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.two_d.Mixin2D.split_by_perimeter", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.two_d.Mixin2D.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.three_d.Mixin3D": [ + "build123d.topology.shape_core.Shape.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.three_d.Mixin3D.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.three_d.Mixin3D.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.three_d.Mixin3D.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.build_common.Builder": [ + "build123d.build_common.Builder.__add__", + "build123d.build_common.Builder.__and__", + "build123d.build_common.Builder.__enter__", + "build123d.build_common.Builder.__exit__", + "build123d.build_common.Builder.__sub__", + "build123d.build_common.Builder.edge", + "build123d.build_common.Builder.edges", + "build123d.build_common.Builder.face", + "build123d.build_common.Builder.faces", + "build123d.build_common.Builder.label", + "build123d.build_common.Builder.lasts", + "build123d.build_common.Builder.max_dimension", + "build123d.build_common.Builder.new_edges", + "build123d.build_common.Builder.news", + "build123d.build_common.Builder.solid", + "build123d.build_common.Builder.solids", + "build123d.build_common.Builder.validate_inputs", + "build123d.build_common.Builder.vertex", + "build123d.build_common.Builder.vertices", + "build123d.build_common.Builder.wire", + "build123d.build_common.Builder.wires" + ], + "build123d.build_common.BaseObjectMeta": [ + "build123d.build_common.BaseObjectMeta.__call__" + ], + "build123d.build_enums.Align": [], + "build123d.build_enums.ApproxOption": [], + "build123d.build_enums.AngularDirection": [], + "build123d.build_enums.CenterOf": [], + "build123d.build_enums.ContinuityLevel": [], + "build123d.build_enums.Convexity": [], + "build123d.build_enums.Extrinsic": [], + "build123d.build_enums.FontStyle": [], + "build123d.build_enums.FrameMethod": [], + "build123d.build_enums.GeomType": [], + "build123d.build_enums.HeadType": [], + "build123d.build_enums.Intrinsic": [], + "build123d.build_enums.Keep": [], + "build123d.build_enums.Kind": [], + "build123d.build_enums.Sagitta": [], + "build123d.build_enums.LengthMode": [], + "build123d.build_enums.MeshType": [], + "build123d.build_enums.Mode": [], + "build123d.build_enums.NumberDisplay": [], + "build123d.build_enums.PageSize": [], + "build123d.build_enums.Tangency": [], + "build123d.build_enums.PositionMode": [], + "build123d.build_enums.PrecisionMode": [], + "build123d.build_enums.Select": [], + "build123d.build_enums.Side": [], + "build123d.build_enums.SortBy": [], + "build123d.build_enums.TextAlign": [], + "build123d.build_enums.Transition": [], + "build123d.build_enums.Unit": [], + "build123d.build_enums.Until": [], + "build123d.build_common.HexLocations": [ + "build123d.build_common.LocationList.__enter__", + "build123d.build_common.LocationList.__exit__", + "build123d.build_common.LocationList.locations" + ], + "build123d.build_common.PolarLocations": [ + "build123d.build_common.LocationList.__enter__", + "build123d.build_common.LocationList.__exit__", + "build123d.build_common.LocationList.locations" + ], + "build123d.build_common.Locations": [ + "build123d.build_common.LocationList.__enter__", + "build123d.build_common.LocationList.__exit__", + "build123d.build_common.LocationList.locations" + ], + "build123d.build_common.GridLocations": [ + "build123d.build_common.LocationList.__enter__", + "build123d.build_common.LocationList.__exit__", + "build123d.build_common.LocationList.locations" + ], + "build123d.build_line.BuildLine": [ + "build123d.build_common.Builder.__add__", + "build123d.build_common.Builder.__and__", + "build123d.build_common.Builder.__enter__", + "build123d.build_common.Builder.__exit__", + "build123d.build_common.Builder.__sub__", + "build123d.build_common.Builder.edge", + "build123d.build_common.Builder.edges", + "build123d.build_line.BuildLine.face", + "build123d.build_line.BuildLine.faces", + "build123d.build_common.Builder.label", + "build123d.build_common.Builder.lasts", + "build123d.build_line.BuildLine.line", + "build123d.build_line.BuildLine.line_local", + "build123d.build_common.Builder.max_dimension", + "build123d.build_common.Builder.new_edges", + "build123d.build_common.Builder.news", + "build123d.build_line.BuildLine.solid", + "build123d.build_line.BuildLine.solids", + "build123d.build_common.Builder.validate_inputs", + "build123d.build_common.Builder.vertex", + "build123d.build_common.Builder.vertices", + "build123d.build_common.Builder.wire", + "build123d.build_common.Builder.wires" + ], + "build123d.build_part.BuildPart": [ + "build123d.build_common.Builder.__add__", + "build123d.build_common.Builder.__and__", + "build123d.build_common.Builder.__enter__", + "build123d.build_common.Builder.__exit__", + "build123d.build_common.Builder.__sub__", + "build123d.build_common.Builder.edge", + "build123d.build_common.Builder.edges", + "build123d.build_common.Builder.face", + "build123d.build_common.Builder.faces", + "build123d.build_common.Builder.label", + "build123d.build_common.Builder.lasts", + "build123d.build_part.BuildPart.location", + "build123d.build_common.Builder.max_dimension", + "build123d.build_common.Builder.new_edges", + "build123d.build_common.Builder.news", + "build123d.build_part.BuildPart.part", + "build123d.build_part.BuildPart.part_local", + "build123d.build_part.BuildPart.pending_edges_as_wire", + "build123d.build_common.Builder.solid", + "build123d.build_common.Builder.solids", + "build123d.build_common.Builder.validate_inputs", + "build123d.build_common.Builder.vertex", + "build123d.build_common.Builder.vertices", + "build123d.build_common.Builder.wire", + "build123d.build_common.Builder.wires" + ], + "build123d.build_sketch.BuildSketch": [ + "build123d.build_common.Builder.__add__", + "build123d.build_common.Builder.__and__", + "build123d.build_common.Builder.__enter__", + "build123d.build_common.Builder.__exit__", + "build123d.build_common.Builder.__sub__", + "build123d.build_sketch.BuildSketch.consolidate_edges", + "build123d.build_common.Builder.edge", + "build123d.build_common.Builder.edges", + "build123d.build_common.Builder.face", + "build123d.build_common.Builder.faces", + "build123d.build_common.Builder.label", + "build123d.build_common.Builder.lasts", + "build123d.build_common.Builder.max_dimension", + "build123d.build_common.Builder.new_edges", + "build123d.build_common.Builder.news", + "build123d.build_sketch.BuildSketch.sketch", + "build123d.build_sketch.BuildSketch.sketch_local", + "build123d.build_sketch.BuildSketch.solid", + "build123d.build_sketch.BuildSketch.solids", + "build123d.build_common.Builder.validate_inputs", + "build123d.build_common.Builder.vertex", + "build123d.build_common.Builder.vertices", + "build123d.build_common.Builder.wire", + "build123d.build_common.Builder.wires" + ], + "build123d.objects_curve.BaseCurveObject": [ + "build123d.topology.composite.Curve.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.composite.Curve.__matmul__", + "build123d.topology.composite.Curve.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.composite.Curve.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.composite.Curve.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.BaseEdgeObject": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.BaseLineObject": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.one_d.Wire.chamfer_2d", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Wire.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.one_d.Wire.combine", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.one_d.Wire.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Wire.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Wire.fillet_2d", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.one_d.Wire.fix_degenerate_edges", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Wire.geom_adaptor", + "build123d.topology.one_d.Wire.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Wire.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Wire.make_convex_hull", + "build123d.topology.one_d.Wire.make_ellipse", + "build123d.topology.one_d.Wire.make_polygon", + "build123d.topology.one_d.Wire.make_rect", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.one_d.Wire.order_chamfer_edges", + "build123d.topology.one_d.Wire.order_edges", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Wire.param_at", + "build123d.topology.one_d.Wire.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Wire.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Wire.stitch", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Wire.trim", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.Airfoil": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.objects_curve.Airfoil.camber_line", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.one_d.Wire.chamfer_2d", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Wire.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.one_d.Wire.combine", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.one_d.Wire.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Wire.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Wire.fillet_2d", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.one_d.Wire.fix_degenerate_edges", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Wire.geom_adaptor", + "build123d.topology.one_d.Wire.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Wire.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Wire.make_convex_hull", + "build123d.topology.one_d.Wire.make_ellipse", + "build123d.topology.one_d.Wire.make_polygon", + "build123d.topology.one_d.Wire.make_rect", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.one_d.Wire.order_chamfer_edges", + "build123d.topology.one_d.Wire.order_edges", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Wire.param_at", + "build123d.topology.one_d.Wire.param_at_point", + "build123d.objects_curve.Airfoil.parse_naca4", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Wire.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Wire.stitch", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Wire.trim", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.Bezier": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.BlendCurve": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.BSpline": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.CenterArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.ConstrainedArcs": [ + "build123d.topology.composite.Curve.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.composite.Curve.__matmul__", + "build123d.topology.composite.Curve.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.composite.Curve.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.composite.Curve.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.ConstrainedLines": [ + "build123d.topology.composite.Curve.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.composite.Curve.__matmul__", + "build123d.topology.composite.Curve.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.composite.Curve.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.composite.Curve.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.DoubleTangentArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.EllipticalCenterArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.EllipticalStartArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.ParabolicCenterArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.HyperbolicCenterArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.FilletPolyline": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.one_d.Wire.chamfer_2d", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Wire.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.one_d.Wire.combine", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.one_d.Wire.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Wire.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Wire.fillet_2d", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.one_d.Wire.fix_degenerate_edges", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Wire.geom_adaptor", + "build123d.topology.one_d.Wire.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Wire.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Wire.make_convex_hull", + "build123d.topology.one_d.Wire.make_ellipse", + "build123d.topology.one_d.Wire.make_polygon", + "build123d.topology.one_d.Wire.make_rect", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.one_d.Wire.order_chamfer_edges", + "build123d.topology.one_d.Wire.order_edges", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Wire.param_at", + "build123d.topology.one_d.Wire.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Wire.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Wire.stitch", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Wire.trim", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.Helix": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.IntersectingLine": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.Line": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.PolarLine": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.Polyline": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.one_d.Wire.chamfer_2d", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Wire.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.one_d.Wire.combine", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.one_d.Wire.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Wire.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Wire.fillet_2d", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.one_d.Wire.fix_degenerate_edges", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Wire.geom_adaptor", + "build123d.topology.one_d.Wire.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Wire.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Wire.make_convex_hull", + "build123d.topology.one_d.Wire.make_ellipse", + "build123d.topology.one_d.Wire.make_polygon", + "build123d.topology.one_d.Wire.make_rect", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.one_d.Wire.order_chamfer_edges", + "build123d.topology.one_d.Wire.order_edges", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Wire.param_at", + "build123d.topology.one_d.Wire.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Wire.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Wire.stitch", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Wire.trim", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.RadiusArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.SagittaArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.Spline": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.TangentArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.JernArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_curve.ThreePointArc": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.drafting.ArrowHead": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.drafting.Arrow": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.BaseSketchObject": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Circle": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.drafting.Draft": [ + "build123d.drafting.Draft.is_metric" + ], + "build123d.drafting.DimensionLine": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Ellipse": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.drafting.ExtensionLine": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Polygon": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Rectangle": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.RectangleRounded": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.RegularPolygon": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.SlotArc": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.SlotCenterPoint": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.SlotCenterToCenter": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.SlotOverall": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Superellipse": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Text": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.drafting.TechnicalDrawing": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Trapezoid": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_sketch.Triangle": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.BasePartObject": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Box": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Cone": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.ConvexPolyhedron": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.CounterBoreHole": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.CounterSinkHole": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Cylinder": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Hole": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Sphere": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Torus": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.objects_part.Wedge": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.geometry.BoundBox": [ + "build123d.geometry.BoundBox.add", + "build123d.geometry.BoundBox.center", + "build123d.geometry.BoundBox.contains", + "build123d.geometry.BoundBox.contains_properly", + "build123d.geometry.BoundBox.covered_by", + "build123d.geometry.BoundBox.covers", + "build123d.geometry.BoundBox.diagonal", + "build123d.geometry.BoundBox.disjoint", + "build123d.geometry.BoundBox.find_outside_box_2d", + "build123d.geometry.BoundBox.from_topo_ds", + "build123d.geometry.BoundBox.intersects", + "build123d.geometry.BoundBox.is_inside", + "build123d.geometry.BoundBox.measure", + "build123d.geometry.BoundBox.overlaps", + "build123d.geometry.BoundBox.to_align_offset", + "build123d.geometry.BoundBox.touches", + "build123d.geometry.BoundBox.within" + ], + "build123d.geometry.OrientedBoundBox": [ + "build123d.geometry.OrientedBoundBox.center", + "build123d.geometry.OrientedBoundBox.corners", + "build123d.geometry.OrientedBoundBox.diagonal", + "build123d.geometry.OrientedBoundBox.is_completely_inside", + "build123d.geometry.OrientedBoundBox.is_outside", + "build123d.geometry.OrientedBoundBox.location", + "build123d.geometry.OrientedBoundBox.plane", + "build123d.geometry.OrientedBoundBox.size", + "build123d.geometry.OrientedBoundBox.wrapped", + "build123d.geometry.OrientedBoundBox.x_direction", + "build123d.geometry.OrientedBoundBox.y_direction", + "build123d.geometry.OrientedBoundBox.z_direction" + ], + "build123d.geometry.Rotation": [ + "build123d.geometry.Location.__and__", + "build123d.geometry.Location.__mul__", + "build123d.geometry.Location.__neg__", + "build123d.geometry.Location.center", + "build123d.geometry.Location.intersect", + "build123d.geometry.Location.inverse", + "build123d.geometry.Location.mirror", + "build123d.geometry.Location.orientation", + "build123d.geometry.Location.position", + "build123d.geometry.Location.wrapped", + "build123d.geometry.Location.x_axis", + "build123d.geometry.Location.y_axis", + "build123d.geometry.Location.z_axis" + ], + "build123d.geometry.Pos": [ + "build123d.geometry.Location.__and__", + "build123d.geometry.Location.__mul__", + "build123d.geometry.Location.__neg__", + "build123d.geometry.Location.center", + "build123d.geometry.Location.intersect", + "build123d.geometry.Location.inverse", + "build123d.geometry.Location.mirror", + "build123d.geometry.Location.orientation", + "build123d.geometry.Location.position", + "build123d.geometry.Location.wrapped", + "build123d.geometry.Location.x_axis", + "build123d.geometry.Location.y_axis", + "build123d.geometry.Location.z_axis" + ], + "build123d.topology.shape_core.ShapeList": [ + "build123d.topology.shape_core.ShapeList.__add__", + "build123d.topology.shape_core.ShapeList.__and__", + "build123d.topology.shape_core.ShapeList.__sub__", + "build123d.topology.shape_core.ShapeList.center", + "build123d.topology.shape_core.ShapeList.compound", + "build123d.topology.shape_core.ShapeList.compounds", + "build123d.topology.shape_core.ShapeList.edge", + "build123d.topology.shape_core.ShapeList.edges", + "build123d.topology.shape_core.ShapeList.expand", + "build123d.topology.shape_core.ShapeList.face", + "build123d.topology.shape_core.ShapeList.faces", + "build123d.topology.shape_core.ShapeList.filter_by", + "build123d.topology.shape_core.ShapeList.filter_by_position", + "build123d.topology.shape_core.ShapeList.first", + "build123d.topology.shape_core.ShapeList.group_by", + "build123d.topology.shape_core.ShapeList.last", + "build123d.topology.shape_core.ShapeList.shell", + "build123d.topology.shape_core.ShapeList.shells", + "build123d.topology.shape_core.ShapeList.solid", + "build123d.topology.shape_core.ShapeList.solids", + "build123d.topology.shape_core.ShapeList.sort_by", + "build123d.topology.shape_core.ShapeList.sort_by_distance", + "build123d.topology.shape_core.ShapeList.vertex", + "build123d.topology.shape_core.ShapeList.vertices", + "build123d.topology.shape_core.ShapeList.wire", + "build123d.topology.shape_core.ShapeList.wires" + ], + "build123d.geometry.Axis": [ + "build123d.geometry.Axis.__and__", + "build123d.geometry.Axis.__neg__", + "build123d.geometry.Axis.angle_between", + "build123d.geometry.Axis.direction", + "build123d.geometry.Axis.intersect", + "build123d.geometry.Axis.is_coaxial", + "build123d.geometry.Axis.is_normal", + "build123d.geometry.Axis.is_opposite", + "build123d.geometry.Axis.is_parallel", + "build123d.geometry.Axis.is_skew", + "build123d.geometry.Axis.located", + "build123d.geometry.Axis.location", + "build123d.geometry.Axis.position", + "build123d.geometry.Axis.reverse", + "build123d.geometry.Axis.wrapped" + ], + "build123d.geometry.Color": [ + "build123d.geometry.Color.categorical_set" + ], + "build123d.topology.composite.Curve": [ + "build123d.topology.composite.Curve.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.composite.Curve.__matmul__", + "build123d.topology.composite.Curve.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.composite.Curve.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.composite.Curve.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.geometry.Vector": [ + "build123d.geometry.Vector.X", + "build123d.geometry.Vector.Y", + "build123d.geometry.Vector.Z", + "build123d.geometry.Vector.__add__", + "build123d.geometry.Vector.__and__", + "build123d.geometry.Vector.__mul__", + "build123d.geometry.Vector.__neg__", + "build123d.geometry.Vector.__radd__", + "build123d.geometry.Vector.__rmul__", + "build123d.geometry.Vector.__sub__", + "build123d.geometry.Vector.add", + "build123d.geometry.Vector.center", + "build123d.geometry.Vector.cross", + "build123d.geometry.Vector.distance_to_plane", + "build123d.geometry.Vector.dot", + "build123d.geometry.Vector.get_angle", + "build123d.geometry.Vector.get_signed_angle", + "build123d.geometry.Vector.intersect", + "build123d.geometry.Vector.length", + "build123d.geometry.Vector.multiply", + "build123d.geometry.Vector.normalized", + "build123d.geometry.Vector.project_to_line", + "build123d.geometry.Vector.project_to_plane", + "build123d.geometry.Vector.reverse", + "build123d.geometry.Vector.rotate", + "build123d.geometry.Vector.signed_distance_from_plane", + "build123d.geometry.Vector.sub", + "build123d.geometry.Vector.to_dir", + "build123d.geometry.Vector.to_pnt", + "build123d.geometry.Vector.transform", + "build123d.geometry.Vector.wrapped" + ], + "build123d.topology.zero_d.Vertex": [ + "build123d.topology.zero_d.Vertex.X", + "build123d.topology.zero_d.Vertex.Y", + "build123d.topology.zero_d.Vertex.Z", + "build123d.topology.zero_d.Vertex.__add__", + "build123d.topology.zero_d.Vertex.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.zero_d.Vertex.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.zero_d.Vertex.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.zero_d.Vertex.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.zero_d.Vertex.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.zero_d.Vertex.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.zero_d.Vertex.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.zero_d.Vertex.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.zero_d.Vertex.vertex", + "build123d.topology.zero_d.Vertex.vertices", + "build123d.topology.zero_d.Vertex.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.one_d.Edge": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.one_d.Edge.arc_center", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Edge.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.one_d.Edge.distribute_locations", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Edge.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Edge.find_intersection_points", + "build123d.topology.one_d.Edge.find_tangent", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Edge.geom_adaptor", + "build123d.topology.one_d.Edge.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Edge.is_infinite", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Edge.make_bezier", + "build123d.topology.one_d.Edge.make_bspline", + "build123d.topology.one_d.Edge.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Edge.make_constrained_arcs", + "build123d.topology.one_d.Edge.make_constrained_lines", + "build123d.topology.one_d.Edge.make_ellipse", + "build123d.topology.one_d.Edge.make_helix", + "build123d.topology.one_d.Edge.make_hyperbola", + "build123d.topology.one_d.Edge.make_line", + "build123d.topology.one_d.Edge.make_mid_way", + "build123d.topology.one_d.Edge.make_parabola", + "build123d.topology.one_d.Edge.make_spline", + "build123d.topology.one_d.Edge.make_spline_approx", + "build123d.topology.one_d.Edge.make_tangent_arc", + "build123d.topology.one_d.Edge.make_three_point_arc", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Edge.param_at", + "build123d.topology.one_d.Edge.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Edge.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.one_d.Edge.reversed", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Edge.trim", + "build123d.topology.one_d.Edge.trim_infinite", + "build123d.topology.one_d.Edge.trim_to_length", + "build123d.topology.one_d.Edge.trim_to_other", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.one_d.Wire": [ + "build123d.topology.one_d.Mixin1D.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.one_d.Mixin1D.__matmul__", + "build123d.topology.one_d.Mixin1D.__mod__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.one_d.Mixin1D.__xor__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.one_d.Mixin1D.center", + "build123d.topology.one_d.Wire.chamfer_2d", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.one_d.Wire.close", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.one_d.Wire.combine", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.one_d.Mixin1D.common_plane", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.one_d.Mixin1D.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.one_d.Mixin1D.curvature_comb", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.one_d.Mixin1D.derivative_at", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.one_d.Wire.edges", + "build123d.topology.one_d.Mixin1D.end_point", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.one_d.Wire.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.one_d.Wire.fillet_2d", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.one_d.Wire.fix_degenerate_edges", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.one_d.Wire.geom_adaptor", + "build123d.topology.one_d.Wire.geom_equal", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.one_d.Mixin1D.is_closed", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.one_d.Mixin1D.is_forward", + "build123d.topology.one_d.Mixin1D.is_interior", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.one_d.Mixin1D.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.one_d.Mixin1D.location_at", + "build123d.topology.one_d.Mixin1D.locations", + "build123d.topology.one_d.Wire.make_circle", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.one_d.Wire.make_convex_hull", + "build123d.topology.one_d.Wire.make_ellipse", + "build123d.topology.one_d.Wire.make_polygon", + "build123d.topology.one_d.Wire.make_rect", + "build123d.topology.one_d.Mixin1D.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.one_d.Mixin1D.normal", + "build123d.topology.one_d.Mixin1D.offset_2d", + "build123d.topology.one_d.Wire.order_chamfer_edges", + "build123d.topology.one_d.Wire.order_edges", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.one_d.Wire.param_at", + "build123d.topology.one_d.Wire.param_at_point", + "build123d.topology.one_d.Mixin1D.perpendicular_line", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.one_d.Mixin1D.position_at", + "build123d.topology.one_d.Mixin1D.positions", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.one_d.Mixin1D.project", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.one_d.Wire.project_to_shape", + "build123d.topology.one_d.Mixin1D.project_to_viewport", + "build123d.topology.one_d.Mixin1D.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.one_d.Mixin1D.start_point", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.one_d.Wire.stitch", + "build123d.topology.one_d.Mixin1D.tangent_angle_at", + "build123d.topology.one_d.Mixin1D.tangent_at", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.shape_core.Shape.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.one_d.Wire.trim", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.one_d.Mixin1D.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.two_d.Face": [ + "build123d.topology.shape_core.Shape.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.two_d.Mixin2D.__neg__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.two_d.Face.area_without_holes", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.two_d.Face.axes_of_symmetry", + "build123d.topology.two_d.Face.axis_of_rotation", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.two_d.Face.center", + "build123d.topology.two_d.Face.center_location", + "build123d.topology.two_d.Face.chamfer_2d", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.two_d.Face.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.two_d.Face.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.two_d.Face.fillet_2d", + "build123d.topology.two_d.Mixin2D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.two_d.Face.geom_adaptor", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.two_d.Face.geometry", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.two_d.Face.inner_wires", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.two_d.Face.is_circular_concave", + "build123d.topology.two_d.Face.is_circular_convex", + "build123d.topology.two_d.Face.is_coplanar", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.two_d.Face.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.two_d.Face.is_planar", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.two_d.Face.length", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.two_d.Face.location_at", + "build123d.topology.two_d.Face.make_bezier_surface", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.two_d.Face.make_gordon_surface", + "build123d.topology.two_d.Face.make_holes", + "build123d.topology.two_d.Face.make_rect", + "build123d.topology.two_d.Face.make_surface", + "build123d.topology.two_d.Face.make_surface_from_array_of_points", + "build123d.topology.two_d.Face.make_surface_from_curves", + "build123d.topology.two_d.Face.make_surface_patch", + "build123d.topology.two_d.Face.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.two_d.Face.normal_at", + "build123d.topology.two_d.Mixin2D.offset", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.two_d.Face.outer_wire", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.two_d.Face.position_at", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.two_d.Face.project_to_shape", + "build123d.topology.two_d.Mixin2D.project_to_viewport", + "build123d.topology.two_d.Face.radii", + "build123d.topology.two_d.Face.radius", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.two_d.Face.revolve", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.two_d.Face.seams", + "build123d.topology.two_d.Face.semi_angle", + "build123d.topology.two_d.Face.sew_faces", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.two_d.Mixin2D.split_by_perimeter", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.two_d.Face.sweep", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.two_d.Mixin2D.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.two_d.Face.uv_face", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.two_d.Face.volume", + "build123d.topology.two_d.Face.width", + "build123d.topology.two_d.Face.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.two_d.Face.without_holes", + "build123d.topology.two_d.Face.wrap", + "build123d.topology.two_d.Face.wrap_faces", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.geometry.Matrix": [ + "build123d.geometry.Matrix.inverse", + "build123d.geometry.Matrix.multiply", + "build123d.geometry.Matrix.rotate", + "build123d.geometry.Matrix.transposed_list" + ], + "build123d.topology.three_d.Solid": [ + "build123d.topology.shape_core.Shape.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.three_d.Mixin3D.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.three_d.Solid.draft", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.three_d.Solid.extrude", + "build123d.topology.three_d.Solid.extrude_linear_with_rotation", + "build123d.topology.three_d.Solid.extrude_taper", + "build123d.topology.three_d.Solid.extrude_until", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.three_d.Solid.from_bounding_box", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.three_d.Solid.make_box", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.three_d.Solid.make_cone", + "build123d.topology.three_d.Solid.make_cylinder", + "build123d.topology.three_d.Solid.make_loft", + "build123d.topology.three_d.Solid.make_sphere", + "build123d.topology.three_d.Solid.make_torus", + "build123d.topology.three_d.Solid.make_wedge", + "build123d.topology.three_d.Solid.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.three_d.Mixin3D.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.three_d.Solid.revolve", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.three_d.Solid.sweep", + "build123d.topology.three_d.Solid.sweep_multi", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.three_d.Solid.thicken", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.three_d.Solid.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.three_d.Solid.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.two_d.Shell": [ + "build123d.topology.shape_core.Shape.__add__", + "build123d.topology.shape_core.Shape.__and__", + "build123d.topology.two_d.Mixin2D.__neg__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.shape_core.Shape.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.two_d.Shell.center", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.shape_core.Shape.compound", + "build123d.topology.shape_core.Shape.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.two_d.Shell.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.two_d.Mixin2D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.two_d.Shell.location_at", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.two_d.Shell.make_loft", + "build123d.topology.two_d.Shell.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.two_d.Mixin2D.offset", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.two_d.Mixin2D.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.two_d.Shell.revolve", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.two_d.Mixin2D.split_by_perimeter", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.two_d.Shell.sweep", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.two_d.Mixin2D.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.two_d.Shell.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.topology.composite.Part": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.geometry.Plane": [ + "build123d.geometry.Plane.__and__", + "build123d.geometry.Plane.__mul__", + "build123d.geometry.Plane.__neg__", + "build123d.geometry.Plane.__rmul__", + "build123d.geometry.Plane.contains", + "build123d.geometry.Plane.forward_transform", + "build123d.geometry.Plane.from_local_coords", + "build123d.geometry.Plane.get_topods_face_normal", + "build123d.geometry.Plane.intersect", + "build123d.geometry.Plane.location", + "build123d.geometry.Plane.location_between", + "build123d.geometry.Plane.move", + "build123d.geometry.Plane.moved", + "build123d.geometry.Plane.offset", + "build123d.geometry.Plane.origin", + "build123d.geometry.Plane.reverse", + "build123d.geometry.Plane.reverse_transform", + "build123d.geometry.Plane.rotated", + "build123d.geometry.Plane.shift_origin", + "build123d.geometry.Plane.to_gp_ax2", + "build123d.geometry.Plane.to_gp_ax3", + "build123d.geometry.Plane.to_local_coords", + "build123d.geometry.Plane.wrapped", + "build123d.geometry.Plane.x_dir", + "build123d.geometry.Plane.y_dir", + "build123d.geometry.Plane.z_dir" + ], + "build123d.topology.composite.Compound": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.geometry.Location": [ + "build123d.geometry.Location.__and__", + "build123d.geometry.Location.__mul__", + "build123d.geometry.Location.__neg__", + "build123d.geometry.Location.center", + "build123d.geometry.Location.intersect", + "build123d.geometry.Location.inverse", + "build123d.geometry.Location.mirror", + "build123d.geometry.Location.orientation", + "build123d.geometry.Location.position", + "build123d.geometry.Location.wrapped", + "build123d.geometry.Location.x_axis", + "build123d.geometry.Location.y_axis", + "build123d.geometry.Location.z_axis" + ], + "build123d.geometry.GeomEncoder": [ + "build123d.geometry.GeomEncoder.default", + "build123d.geometry.GeomEncoder.geometry_hook" + ], + "build123d.topology.shape_core.Joint": [ + "build123d.topology.shape_core.Joint.connect_to", + "build123d.topology.shape_core.Joint.location", + "build123d.topology.shape_core.Joint.relative_to", + "build123d.topology.shape_core.Joint.symbol" + ], + "build123d.joints.RigidJoint": [ + "build123d.joints.RigidJoint.connect_to", + "build123d.joints.RigidJoint.location", + "build123d.joints.RigidJoint.relative_to", + "build123d.joints.RigidJoint.symbol" + ], + "build123d.joints.RevoluteJoint": [ + "build123d.joints.RevoluteJoint.connect_to", + "build123d.joints.RevoluteJoint.location", + "build123d.joints.RevoluteJoint.relative_to", + "build123d.joints.RevoluteJoint.symbol" + ], + "build123d.topology.composite.Sketch": [ + "build123d.topology.composite.Compound.__add__", + "build123d.topology.composite.Compound.__and__", + "build123d.topology.shape_core.Shape.__rmul__", + "build123d.topology.composite.Compound.__sub__", + "build123d.topology.shape_core.Shape.area", + "build123d.topology.shape_core.Shape.as_shape", + "build123d.topology.shape_core.Shape.bounding_box", + "build123d.topology.shape_core.Shape.cast", + "build123d.topology.composite.Compound.center", + "build123d.topology.three_d.Mixin3D.chamfer", + "build123d.topology.shape_core.Shape.clean", + "build123d.topology.shape_core.Shape.closest_points", + "build123d.topology.shape_core.Shape.color", + "build123d.topology.shape_core.Shape.combined_center", + "build123d.topology.composite.Compound.compound", + "build123d.topology.composite.Compound.compounds", + "build123d.topology.shape_core.Shape.compute_mass", + "build123d.topology.shape_core.Shape.compute_volume", + "build123d.topology.shape_core.Shape.convexity", + "build123d.topology.shape_core.Shape.copy_attributes_to", + "build123d.topology.shape_core.Shape.cut", + "build123d.topology.shape_core.Shape.distance", + "build123d.topology.shape_core.Shape.distance_to", + "build123d.topology.shape_core.Shape.distance_to_with_closest_points", + "build123d.topology.shape_core.Shape.distances", + "build123d.topology.composite.Compound.do_children_intersect", + "build123d.topology.three_d.Mixin3D.dprism", + "build123d.topology.shape_core.Shape.edge", + "build123d.topology.shape_core.Shape.edges", + "build123d.topology.shape_core.Shape.entities", + "build123d.topology.composite.Compound.extrude", + "build123d.topology.shape_core.Shape.face", + "build123d.topology.shape_core.Shape.faces", + "build123d.topology.shape_core.Shape.faces_intersected_by_axis", + "build123d.topology.three_d.Mixin3D.fillet", + "build123d.topology.three_d.Mixin3D.find_intersection_points", + "build123d.topology.shape_core.Shape.fix", + "build123d.topology.shape_core.Shape.fuse", + "build123d.topology.shape_core.Shape.geom_type", + "build123d.topology.shape_core.Shape.get_shape_list", + "build123d.topology.shape_core.Shape.get_single_shape", + "build123d.topology.shape_core.Shape.get_top_level_shapes", + "build123d.topology.composite.Compound.get_type", + "build123d.topology.shape_core.Shape.global_location", + "build123d.topology.three_d.Mixin3D.hollow", + "build123d.topology.shape_core.Shape.intersect", + "build123d.topology.shape_core.Shape.is_equal", + "build123d.topology.three_d.Mixin3D.is_inside", + "build123d.topology.shape_core.Shape.is_manifold", + "build123d.topology.shape_core.Shape.is_null", + "build123d.topology.shape_core.Shape.is_same", + "build123d.topology.shape_core.Shape.is_valid", + "build123d.topology.shape_core.Shape.locate", + "build123d.topology.shape_core.Shape.located", + "build123d.topology.shape_core.Shape.location", + "build123d.topology.shape_core.Shape.make_composite", + "build123d.topology.composite.Compound.make_text", + "build123d.topology.composite.Compound.make_triad", + "build123d.topology.composite.Compound.mass", + "build123d.topology.shape_core.Shape.material", + "build123d.topology.shape_core.Shape.matrix_of_inertia", + "build123d.topology.three_d.Mixin3D.max_fillet", + "build123d.topology.shape_core.Shape.mesh", + "build123d.topology.shape_core.Shape.mirror", + "build123d.topology.shape_core.Shape.move", + "build123d.topology.shape_core.Shape.moved", + "build123d.topology.three_d.Mixin3D.offset_3d", + "build123d.topology.shape_core.Shape.orientation", + "build123d.topology.shape_core.Shape.oriented_bounding_box", + "build123d.topology.shape_core.Shape.position", + "build123d.topology.shape_core.Shape.principal_properties", + "build123d.topology.shape_core.Shape.project_faces", + "build123d.topology.composite.Compound.project_to_viewport", + "build123d.topology.shape_core.Shape.radius_of_gyration", + "build123d.topology.shape_core.Shape.register_composite_factory", + "build123d.topology.shape_core.Shape.register_geometry_constructor", + "build123d.topology.shape_core.Shape.register_shape_constructor", + "build123d.topology.composite.Compound.resolve_font", + "build123d.topology.shape_core.Shape.rotate", + "build123d.topology.shape_core.Shape.scale", + "build123d.topology.shape_core.Shape.shape_type", + "build123d.topology.shape_core.Shape.shell", + "build123d.topology.shape_core.Shape.shells", + "build123d.topology.shape_core.Shape.show_topology", + "build123d.topology.shape_core.Shape.solid", + "build123d.topology.shape_core.Shape.solids", + "build123d.topology.shape_core.Shape.split", + "build123d.topology.shape_core.Shape.static_moments", + "build123d.topology.shape_core.Shape.tessellate", + "build123d.topology.shape_core.Shape.tessellate_with_uvs", + "build123d.topology.shape_core.Shape.to_splines", + "build123d.topology.shape_core.Shape.topo_owner", + "build123d.topology.shape_core.Shape.topo_parent", + "build123d.topology.composite.Compound.touch", + "build123d.topology.shape_core.Shape.transform_geometry", + "build123d.topology.shape_core.Shape.transform_shape", + "build123d.topology.shape_core.Shape.transformed", + "build123d.topology.shape_core.Shape.translate", + "build123d.topology.composite.Compound.unwrap", + "build123d.topology.shape_core.Shape.vertex", + "build123d.topology.shape_core.Shape.vertices", + "build123d.topology.composite.Compound.volume", + "build123d.topology.shape_core.Shape.wire", + "build123d.topology.shape_core.Shape.wires", + "build123d.topology.shape_core.Shape.wrapped" + ], + "build123d.joints.LinearJoint": [ + "build123d.joints.LinearJoint.connect_to", + "build123d.joints.LinearJoint.location", + "build123d.joints.LinearJoint.relative_to", + "build123d.joints.LinearJoint.symbol" + ], + "build123d.joints.CylindricalJoint": [ + "build123d.joints.CylindricalJoint.connect_to", + "build123d.joints.CylindricalJoint.location", + "build123d.joints.CylindricalJoint.relative_to", + "build123d.joints.CylindricalJoint.symbol" + ], + "build123d.joints.BallJoint": [ + "build123d.joints.BallJoint.connect_to", + "build123d.joints.BallJoint.location", + "build123d.joints.BallJoint.relative_to", + "build123d.joints.BallJoint.symbol" + ], + "build123d.topology.three_d.DraftAngleError": [], + "build123d.text.FontManager": [ + "build123d.text.FontManager.available_fonts", + "build123d.text.FontManager.check_font", + "build123d.text.FontManager.find_font", + "build123d.text.FontManager.register_folder", + "build123d.text.FontManager.register_font", + "build123d.text.FontManager.register_system_fonts" + ], + "build123d.exporters.Export2D": [], + "build123d.exporters.ExportDXF": [ + "build123d.exporters.ExportDXF.add_layer", + "build123d.exporters.ExportDXF.add_shape", + "build123d.exporters.ExportDXF.write" + ], + "build123d.exporters.ExportSVG": [ + "build123d.exporters.ExportSVG.add_layer", + "build123d.exporters.ExportSVG.add_shape", + "build123d.exporters.ExportSVG.write" + ], + "build123d.exporters.LineType": [], + "build123d.exporters.DotLength": [], + "build123d.mesher.Mesher": [ + "build123d.mesher.Mesher.add_code_to_metadata", + "build123d.mesher.Mesher.add_meta_data", + "build123d.mesher.Mesher.add_shape", + "build123d.mesher.Mesher.get_mesh_properties", + "build123d.mesher.Mesher.get_meta_data", + "build123d.mesher.Mesher.get_meta_data_by_key", + "build123d.mesher.Mesher.library_version", + "build123d.mesher.Mesher.mesh_count", + "build123d.mesher.Mesher.model_unit", + "build123d.mesher.Mesher.read", + "build123d.mesher.Mesher.triangle_counts", + "build123d.mesher.Mesher.vertex_counts", + "build123d.mesher.Mesher.write", + "build123d.mesher.Mesher.write_stream" + ] + }, + "corpus": { + "counting_note": "AST call sites, not runtime execution counts. Constant-false GEN_DOCS branches and __main__ export blocks are omitted; loops/functions are counted syntactically. Operator counts include numeric arithmetic.", + "top_level_calls": { + "BuildSketch": 57, + "BuildPart": 55, + "extrude": 40, + "Circle": 29, + "Rectangle": 25, + "Locations": 23, + "Box": 18, + "Line": 18, + "BuildLine": 16, + "fillet": 15, + "RegularPolygon": 14, + "GridLocations": 11, + "Plane": 10, + "make_face": 9, + "Cylinder": 8, + "mirror": 8, + "offset": 8, + "Spline": 6, + "sweep": 6, + "Polyline": 5, + "PolarLocations": 5, + "JernArc": 5, + "insert": 5, + "Hole": 4, + "CounterBoreHole": 4, + "split": 4, + "revolve": 4, + "RadiusArc": 4, + "Vector": 4, + "chamfer": 3, + "CounterSinkHole": 3, + "PolarLine": 3, + "ThreePointArc": 2, + "Axis": 2, + "loft": 2, + "Sphere": 2, + "Text": 2, + "SlotArc": 2, + "Rot": 2, + "Bezier": 1, + "SlotCenterToCenter": 1, + "Ellipse": 1, + "Location": 1, + "SlotOverall": 1, + "scale": 1, + "section": 1, + "RectangleRounded": 1, + "Color": 1, + "Compound": 1, + "Helix": 1 + }, + "method_calls": { + "faces": 26, + "sort_by": 19, + "edges": 15, + "group_by": 11, + "offset": 11, + "vertices": 9, + "filter_by": 7, + "filter_by_position": 5, + "center": 2, + "wires": 2, + "rotated": 1, + "solids": 1, + "shift_origin": 1, + "rotate": 1, + "reverse": 1, + "basicConfig": 1, + "resolve": 1, + "Path": 1, + "info": 1, + "face": 1, + "bounding_box": 1, + "inner_wires": 1, + "find_intersection_points": 1, + "to_local_coords": 1 + }, + "models": [ + { + "id": 1, + "name": "矩形板", + "file": "models/01_rectangular_plate.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L56-L59", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": {} + }, + { + "id": 2, + "name": "带孔板", + "file": "models/02_plate_with_hole.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L69-L74", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "Cylinder": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Div": 1 + } + }, + { + "id": 3, + "name": "棱柱实体", + "file": "models/03_prismatic_solid.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L83-L89", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "Circle": 1, + "Rectangle": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Div": 2, + "Mult": 1 + } + }, + { + "id": 4, + "name": "直线与圆弧轮廓", + "file": "models/04_lines_and_arcs_profile.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L98-L108", + "builder_context_present": true, + "top_level_call_sites": { + "Line": 3, + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "ThreePointArc": 1, + "make_face": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Mult": 1 + } + }, + { + "id": 5, + "name": "偏置孔与方孔", + "file": "models/05_offset_cutouts.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L117-L126", + "builder_context_present": true, + "top_level_call_sites": { + "Circle": 2, + "Locations": 2, + "BuildPart": 1, + "BuildSketch": 1, + "Rectangle": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": {} + }, + { + "id": 6, + "name": "点阵圆孔", + "file": "models/06_point_list_holes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L135-L142", + "builder_context_present": true, + "top_level_call_sites": { + "Circle": 2, + "BuildPart": 1, + "BuildSketch": 1, + "Locations": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": {} + }, + { + "id": 7, + "name": "多边形孔板", + "file": "models/07_polygon_holes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L150-L157", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "Rectangle": 1, + "Locations": 1, + "RegularPolygon": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Mult": 3 + } + }, + { + "id": 8, + "name": "工字梁", + "file": "models/08_i_beam.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L166-L184", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "Polyline": 1, + "mirror": 1, + "make_face": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Div": 14, + "Sub": 4 + } + }, + { + "id": 9, + "name": "圆角与倒角板", + "file": "models/09_fillets_and_chamfers.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L193-L198", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "chamfer": 1, + "fillet": 1 + }, + "method_call_sites": { + "edges": 2, + "group_by": 1, + "filter_by": 1 + }, + "operator_syntax_counts": {} + }, + { + "id": 10, + "name": "圆角孔板", + "file": "models/10_filleted_hole.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L207-L212", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "Hole": 1, + "fillet": 1 + }, + "method_call_sites": { + "group_by": 1, + "edges": 1 + }, + "operator_syntax_counts": { + "Div": 1 + } + }, + { + "id": 11, + "name": "网格多边形孔", + "file": "models/11_grid_polygon_holes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L221-L232", + "builder_context_present": true, + "top_level_call_sites": { + "fillet": 2, + "BuildPart": 1, + "Box": 1, + "chamfer": 1, + "Hole": 1, + "BuildSketch": 1, + "GridLocations": 1, + "RegularPolygon": 1, + "extrude": 1 + }, + "method_call_sites": { + "edges": 3, + "sort_by": 2, + "group_by": 1, + "filter_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Div": 3 + } + }, + { + "id": 12, + "name": "样条轮廓实体", + "file": "models/12_spline_profile.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L241-L259", + "builder_context_present": true, + "top_level_call_sites": { + "Line": 3, + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "Spline": 1, + "make_face": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": {} + }, + { + "id": 13, + "name": "沉头孔与沉孔盘", + "file": "models/13_countersink_counterbore.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L269-L276", + "builder_context_present": true, + "top_level_call_sites": { + "PolarLocations": 2, + "BuildPart": 1, + "Cylinder": 1, + "Locations": 1, + "CounterSinkHole": 1, + "CounterBoreHole": 1 + }, + "method_call_sites": { + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Mult": 2 + } + }, + { + "id": 14, + "name": "方形截面扫掠", + "file": "models/14_swept_square_tube.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L285-L294", + "builder_context_present": true, + "top_level_call_sites": { + "JernArc": 2, + "BuildPart": 1, + "BuildLine": 1, + "Line": 1, + "BuildSketch": 1, + "Rectangle": 1, + "sweep": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "MatMult": 3, + "Mod": 1, + "Add": 1 + } + }, + { + "id": 15, + "name": "对称轮廓实体", + "file": "models/15_mirrored_profile.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L304-L316", + "builder_context_present": true, + "top_level_call_sites": { + "Line": 5, + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "mirror": 1, + "make_face": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "MatMult": 8, + "Add": 3 + } + }, + { + "id": 16, + "name": "三维镜像组合", + "file": "models/16_mirrored_3d_parts.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L326-L342", + "builder_context_present": true, + "top_level_call_sites": { + "mirror": 4, + "BuildPart": 2, + "Rectangle": 2, + "BuildSketch": 1, + "fillet": 1, + "GridLocations": 1, + "Circle": 1, + "extrude": 1, + "insert": 1 + }, + "method_call_sites": { + "offset": 4, + "vertices": 1 + }, + "operator_syntax_counts": { + "Div": 3 + } + }, + { + "id": 17, + "name": "面镜像棱柱", + "file": "models/17_face_mirror.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L351-L357", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "RegularPolygon": 1, + "extrude": 1, + "mirror": 1, + "Plane": 1 + }, + "method_call_sites": { + "group_by": 1, + "faces": 1 + }, + "operator_syntax_counts": {} + }, + { + "id": 18, + "name": "面定位方孔板", + "file": "models/18_face_cutout.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L367-L376", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "chamfer": 1, + "fillet": 1, + "BuildSketch": 1, + "Rectangle": 1, + "extrude": 1 + }, + "method_call_sites": { + "edges": 2, + "group_by": 1, + "filter_by": 1, + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Mult": 2 + } + }, + { + "id": 19, + "name": "顶点定位缺口板", + "file": "models/19_vertex_cutouts.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L385-L398", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "extrude": 2, + "BuildPart": 1, + "RegularPolygon": 1, + "Axis": 1, + "Locations": 1, + "Circle": 1 + }, + "method_call_sites": { + "sort_by": 2, + "vertices": 2, + "faces": 1, + "group_by": 1 + }, + "operator_syntax_counts": { + "Div": 2 + } + }, + { + "id": 20, + "name": "偏置平面圆柱组合", + "file": "models/20_offset_plane_cylinder.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L407-L414", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "Plane": 1, + "BuildSketch": 1, + "Circle": 1, + "extrude": 1 + }, + "method_call_sites": { + "group_by": 1, + "faces": 1, + "offset": 1 + }, + "operator_syntax_counts": { + "Mult": 1, + "Div": 1 + } + }, + { + "id": 21, + "name": "交叉圆柱", + "file": "models/21_crossed_cylinders.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L423-L431", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "Circle": 2, + "extrude": 2, + "BuildPart": 1, + "Plane": 1 + }, + "method_call_sites": { + "center": 1 + }, + "operator_syntax_counts": { + "Div": 2 + } + }, + { + "id": 22, + "name": "倾斜钻孔板", + "file": "models/22_angled_drill_holes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L440-L448", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "Plane": 1, + "BuildSketch": 1, + "GridLocations": 1, + "Circle": 1, + "extrude": 1 + }, + "method_call_sites": { + "rotated": 1, + "group_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Div": 3 + } + }, + { + "id": 23, + "name": "旋转轮廓实体", + "file": "models/23_revolved_profile.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L457-L475", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "Polyline": 1, + "Line": 1, + "make_face": 1, + "Locations": 1, + "Circle": 1, + "split": 1, + "revolve": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "MatMult": 2 + } + }, + { + "id": 24, + "name": "圆到矩形放样", + "file": "models/24_circle_rectangle_loft.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L484-L492", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "BuildPart": 1, + "Box": 1, + "Circle": 1, + "Rectangle": 1, + "loft": 1 + }, + "method_call_sites": { + "faces": 2, + "group_by": 1, + "offset": 1 + }, + "operator_syntax_counts": { + "Div": 4 + } + }, + { + "id": 25, + "name": "多边形偏置层", + "file": "models/25_offset_polygon_layers.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L501-L512", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 3, + "RegularPolygon": 3, + "offset": 2, + "BuildPart": 1, + "extrude": 1 + }, + "method_call_sites": { + "offset": 2 + }, + "operator_syntax_counts": {} + }, + { + "id": 26, + "name": "薄壁盒", + "file": "models/26_thin_wall_box.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L521-L526", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "offset": 1 + }, + "method_call_sites": { + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": {} + }, + { + "id": 27, + "name": "剖切孔板", + "file": "models/27_split_plate.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L535-L542", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "Box": 1, + "BuildSketch": 1, + "Circle": 1, + "extrude": 1, + "split": 1, + "Plane": 1 + }, + "method_call_sites": { + "sort_by": 2, + "faces": 2, + "offset": 1 + }, + "operator_syntax_counts": { + "Div": 2 + } + }, + { + "id": 28, + "name": "面定位球体钻孔", + "file": "models/28_face_located_sphere_holes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L551-L561", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "RegularPolygon": 1, + "extrude": 1, + "Sphere": 1, + "Locations": 1, + "Hole": 1 + }, + "method_call_sites": { + "group_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Div": 3 + } + }, + { + "id": 29, + "name": "OCC 瓶子", + "file": "models/29_occ_bottle.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L570-L586", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "Line": 2, + "extrude": 2, + "BuildPart": 1, + "BuildLine": 1, + "ThreePointArc": 1, + "mirror": 1, + "make_face": 1, + "fillet": 1, + "Circle": 1, + "offset": 1 + }, + "method_call_sites": { + "sort_by": 2, + "faces": 2, + "offset": 1, + "edges": 1, + "solids": 1 + }, + "operator_syntax_counts": { + "Div": 5, + "MatMult": 3, + "Add": 2 + } + }, + { + "id": 30, + "name": "贝塞尔轮廓实体", + "file": "models/30_bezier_profile.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L595-L621", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "Polyline": 1, + "Bezier": 1, + "make_face": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": {} + }, + { + "id": 31, + "name": "嵌套定位阵列", + "file": "models/31_nested_location_pattern.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L630-L639", + "builder_context_present": true, + "top_level_call_sites": { + "RegularPolygon": 3, + "BuildPart": 1, + "BuildSketch": 1, + "PolarLocations": 1, + "GridLocations": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Mult": 3, + "Div": 1 + } + }, + { + "id": 32, + "name": "变高度阵列", + "file": "models/32_variable_height_pattern.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L648-L657", + "builder_context_present": true, + "top_level_call_sites": { + "RegularPolygon": 2, + "BuildPart": 1, + "BuildSketch": 1, + "PolarLocations": 1, + "insert": 1, + "extrude": 1 + }, + "method_call_sites": { + "faces": 1 + }, + "operator_syntax_counts": { + "Mult": 2, + "Div": 1, + "Add": 1 + } + }, + { + "id": 33, + "name": "函数生成阵列", + "file": "models/33_function_generated_pattern.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L666-L683", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "insert": 2, + "Locations": 1, + "RegularPolygon": 1, + "BuildPart": 1, + "PolarLocations": 1, + "extrude": 1 + }, + "method_call_sites": { + "faces": 1 + }, + "operator_syntax_counts": { + "Add": 2, + "Mult": 2, + "Div": 1 + } + }, + { + "id": 34, + "name": "凸字与凹字板", + "file": "models/34_embossed_debossed_text.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L692-L702", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "Text": 2, + "extrude": 2, + "BuildPart": 1, + "Box": 1 + }, + "method_call_sites": { + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": {} + }, + { + "id": 35, + "name": "直槽与圆弧槽板", + "file": "models/35_curved_slots.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L711-L724", + "builder_context_present": true, + "top_level_call_sites": { + "BuildLine": 2, + "RadiusArc": 2, + "SlotArc": 2, + "BuildPart": 1, + "Box": 1, + "BuildSketch": 1, + "SlotCenterToCenter": 1, + "extrude": 1 + }, + "method_call_sites": { + "edges": 2, + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Div": 7 + } + }, + { + "id": 36, + "name": "拉伸到曲面", + "file": "models/36_extrude_until.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L733-L742", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "BuildPart": 1, + "Locations": 1, + "Circle": 1, + "revolve": 1, + "Rectangle": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": {} + }, + { + "id": 37, + "name": "平面定位复合轮廓", + "file": "models/37_positioned_sketches.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L751-L760", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 3, + "BuildPart": 1, + "Rectangle": 1, + "Circle": 1, + "Plane": 1, + "Ellipse": 1, + "extrude": 1 + }, + "method_call_sites": { + "shift_origin": 1, + "sort_by": 1, + "group_by": 1, + "vertices": 1 + }, + "operator_syntax_counts": {} + }, + { + "id": 38, + "name": "旋转盒体阵列", + "file": "models/38_rotated_boxes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/docs/general_examples.py#L769-L780", + "builder_context_present": true, + "top_level_call_sites": { + "Box": 4, + "Locations": 3, + "BuildPart": 2, + "Rot": 1, + "insert": 1, + "Location": 1 + }, + "method_call_sites": { + "rotate": 1 + }, + "operator_syntax_counts": { + "Mult": 2 + } + }, + { + "id": 39, + "name": "洞洞板 J 形挂钩", + "file": "models/39_pegboard_j_hook.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/pegboard_j_hook.py", + "builder_context_present": true, + "top_level_call_sites": { + "JernArc": 3, + "PolarLine": 3, + "BuildLine": 2, + "Line": 2, + "BuildSketch": 2, + "Circle": 2, + "sweep": 2, + "split": 2, + "Plane": 2, + "BuildPart": 1 + }, + "method_call_sites": { + "wires": 2, + "reverse": 1 + }, + "operator_syntax_counts": { + "Div": 8, + "MatMult": 6, + "Mod": 6, + "Sub": 3, + "Add": 2, + "Mult": 2 + } + }, + { + "id": 40, + "name": "抽屉把手", + "file": "models/40_handle.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/handle.py", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildLine": 1, + "Spline": 1, + "BuildSketch": 1, + "Circle": 1, + "Rectangle": 1, + "fillet": 1, + "sweep": 1 + }, + "method_call_sites": { + "vertices": 1 + }, + "operator_syntax_counts": { + "Add": 1, + "BitXor": 1, + "Div": 1, + "Mod": 1, + "Sub": 1 + } + }, + { + "id": 41, + "name": "轴承座", + "file": "models/41_pillow_block.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/pillow_block.py", + "builder_context_present": true, + "top_level_call_sites": { + "CounterBoreHole": 2, + "BuildPart": 1, + "BuildSketch": 1, + "Rectangle": 1, + "fillet": 1, + "extrude": 1, + "Locations": 1, + "GridLocations": 1 + }, + "method_call_sites": { + "vertices": 1, + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Sub": 2, + "Mult": 2 + } + }, + { + "id": 42, + "name": "DIN 导轨", + "file": "models/42_din_rail.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/din_rail.py", + "builder_context_present": true, + "top_level_call_sites": { + "Rectangle": 3, + "BuildSketch": 2, + "fillet": 2, + "extrude": 2, + "BuildPart": 1, + "GridLocations": 1, + "SlotOverall": 1 + }, + "method_call_sites": { + "filter_by_position": 2, + "vertices": 2, + "basicConfig": 1, + "resolve": 1, + "Path": 1, + "info": 1 + }, + "operator_syntax_counts": { + "Div": 7, + "Sub": 3, + "Mult": 1, + "Add": 1, + "FloorDiv": 1 + } + }, + { + "id": 43, + "name": "积木块", + "file": "models/43_lego.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/lego.py", + "builder_context_present": true, + "top_level_call_sites": { + "Rectangle": 4, + "GridLocations": 4, + "BuildPart": 2, + "Circle": 2, + "BuildSketch": 1, + "offset": 1, + "extrude": 1, + "Locations": 1, + "Box": 1, + "Cylinder": 1 + }, + "method_call_sites": { + "sort_by": 2, + "vertices": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Sub": 5, + "Mult": 3, + "Add": 3, + "Div": 3 + } + }, + { + "id": 44, + "name": "多截面放样壳体", + "file": "models/44_loft.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/loft.py", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 1, + "BuildSketch": 1, + "Plane": 1, + "Circle": 1, + "loft": 1, + "offset": 1 + }, + "method_call_sites": { + "filter_by": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Mult": 4, + "Add": 2, + "Div": 1, + "Sub": 1 + } + }, + { + "id": 45, + "name": "Cherry MX 键帽", + "file": "models/45_key_cap.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/key_cap.py", + "builder_context_present": true, + "top_level_call_sites": { + "Rectangle": 5, + "BuildSketch": 3, + "extrude": 3, + "Circle": 2, + "BuildPart": 1, + "Locations": 1, + "Sphere": 1, + "fillet": 1, + "scale": 1, + "section": 1, + "Plane": 1 + }, + "method_call_sites": { + "filter_by_position": 2, + "edges": 1, + "face": 1, + "offset": 1, + "bounding_box": 1, + "inner_wires": 1, + "faces": 1 + }, + "operator_syntax_counts": { + "Mult": 21, + "Div": 2, + "Sub": 1 + } + }, + { + "id": 46, + "name": "茶杯", + "file": "models/46_tea_cup.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/tea_cup.py", + "builder_context_present": true, + "top_level_call_sites": { + "BuildSketch": 2, + "BuildLine": 2, + "Spline": 2, + "BuildPart": 1, + "Polyline": 1, + "make_face": 1, + "revolve": 1, + "offset": 1, + "Locations": 1, + "Cylinder": 1, + "fillet": 1, + "Axis": 1, + "RectangleRounded": 1, + "sweep": 1, + "Color": 1 + }, + "method_call_sites": { + "filter_by": 1, + "faces": 1, + "edges": 1, + "find_intersection_points": 1, + "to_local_coords": 1 + }, + "operator_syntax_counts": { + "Mult": 15, + "MatMult": 6, + "Add": 3, + "Sub": 3, + "Div": 2, + "BitXor": 1 + } + }, + { + "id": 47, + "name": "花瓶", + "file": "models/47_vase.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/vase.py", + "builder_context_present": true, + "top_level_call_sites": { + "Vector": 4, + "RadiusArc": 2, + "Spline": 2, + "fillet": 2, + "BuildPart": 1, + "BuildSketch": 1, + "BuildLine": 1, + "Line": 1, + "Polyline": 1, + "make_face": 1, + "revolve": 1, + "offset": 1, + "Rot": 1 + }, + "method_call_sites": { + "filter_by": 2, + "edges": 2, + "faces": 1, + "filter_by_position": 1, + "sort_by": 1 + }, + "operator_syntax_counts": { + "MatMult": 11, + "Add": 5, + "Mod": 2, + "Mult": 1 + } + }, + { + "id": 48, + "name": "带孔电路板", + "file": "models/48_circuit_board.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/circuit_board.py", + "builder_context_present": true, + "top_level_call_sites": { + "Circle": 3, + "Locations": 2, + "BuildPart": 1, + "BuildSketch": 1, + "Rectangle": 1, + "GridLocations": 1, + "extrude": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Mult": 5, + "Sub": 3, + "FloorDiv": 2 + } + }, + { + "id": 49, + "name": "四种孔型组合", + "file": "models/49_holes.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/holes.py", + "builder_context_present": true, + "top_level_call_sites": { + "BuildPart": 4, + "Cylinder": 4, + "Locations": 4, + "CounterSinkHole": 2, + "Hole": 1, + "CounterBoreHole": 1, + "Compound": 1 + }, + "method_call_sites": { + "center": 1, + "sort_by": 1, + "faces": 1 + }, + "operator_syntax_counts": {} + }, + { + "id": 50, + "name": "螺旋压缩弹簧", + "file": "models/50_spring.py", + "source_url": "https://github.com/gumyr/build123d/blob/38effd343e1508964673faf59300a5cc68fbedc1/examples/spring.py", + "builder_context_present": false, + "top_level_call_sites": { + "Helix": 1, + "Circle": 1, + "sweep": 1 + }, + "method_call_sites": {}, + "operator_syntax_counts": { + "Mult": 1, + "BitXor": 1 + } + } + ] + }, + "verification": { + "source_report": { + "path": "tools/research/build123dftc/out/validate.json", + "sha256": "a0927de455277a4878768d6eba21c912e2f5af273b1f9c5817653ff80019fe18" + }, + "accepted_models": [ + "01_rectangular_plate", + "02_plate_with_hole", + "03_prismatic_solid", + "04_lines_and_arcs_profile", + "05_offset_cutouts", + "06_point_list_holes", + "07_polygon_holes", + "08_i_beam", + "09_fillets_and_chamfers", + "10_filleted_hole", + "11_grid_polygon_holes", + "12_spline_profile", + "13_countersink_counterbore", + "14_swept_square_tube", + "15_mirrored_profile", + "16_mirrored_3d_parts", + "17_face_mirror", + "18_face_cutout", + "19_vertex_cutouts", + "20_offset_plane_cylinder", + "21_crossed_cylinders", + "22_angled_drill_holes", + "23_revolved_profile", + "24_circle_rectangle_loft", + "25_offset_polygon_layers", + "26_thin_wall_box", + "27_split_plate", + "28_face_located_sphere_holes", + "29_occ_bottle", + "30_bezier_profile", + "31_nested_location_pattern", + "32_variable_height_pattern", + "33_function_generated_pattern", + "34_embossed_debossed_text", + "35_curved_slots", + "36_extrude_until", + "37_positioned_sketches", + "38_rotated_boxes", + "39_pegboard_j_hook", + "40_handle", + "41_pillow_block", + "42_din_rail", + "43_lego", + "44_loft", + "45_key_cap", + "47_vase", + "48_circuit_board", + "49_holes", + "50_spring" + ], + "rejected_or_unverified_models": [ + "46_tea_cup" + ], + "scope": "Sample-level acceptance is not a claim of all-API or all-parameter coverage.", + "verified_top_level_entries": 48, + "verified_public_member_entries": 23 + } +} diff --git a/tools/research/build123dftc/b3ftc/_reference_worker.py b/tools/research/build123dftc/b3ftc/_reference_worker.py new file mode 100644 index 00000000..d034791a --- /dev/null +++ b/tools/research/build123dftc/b3ftc/_reference_worker.py @@ -0,0 +1,44 @@ +"""Compare two STEP files in an independently selected OCCT environment.""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +from _validate_worker import _compare_reference, _read_step, _solid_count, _volume + + +def run(actual_step, reference_step): + import OCP + from OCP.Bnd import Bnd_Box + from OCP.BRepBndLib import BRepBndLib + actual = _read_step(actual_step) + bounds = Bnd_Box() + BRepBndLib.AddOptimal_s(actual, bounds, False, False) + low, high = bounds.CornerMin(), bounds.CornerMax() + bbox = [float(getattr(point, axis)()) for point in (low, high) for axis in "XYZ"] + return {"status": "ok", **_compare_reference([actual], reference_step), + "reference_kernel": getattr(OCP, "__version__", "unknown"), + "roundtrip_actual_volume": _volume(actual), + "roundtrip_actual_bbox": bbox, + "roundtrip_actual_solid_count": _solid_count(actual), + "roundtrip_actual_valid": True} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--actual-step", type=Path, required=True) + parser.add_argument("--reference-step", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + try: + result = run(args.actual_step, args.reference_step) + except Exception as exc: + result = {"status": "reference_error", "reference_status": "error", + "reference_error": f"{type(exc).__name__}: {exc}"} + args.output.write_text(json.dumps(result, ensure_ascii=False, allow_nan=False) + "\n") + return 0 if result["status"] == "ok" else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/research/build123dftc/b3ftc/_trace_worker.py b/tools/research/build123dftc/b3ftc/_trace_worker.py new file mode 100644 index 00000000..8a5267ef --- /dev/null +++ b/tools/research/build123dftc/b3ftc/_trace_worker.py @@ -0,0 +1,13 @@ +"""Private process boundary. Model output goes to the parent's log, not JSON.""" +import json +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from b3ftc.tracer import trace_file + + +if __name__ == "__main__": + source, output = map(Path, sys.argv[1:]) + payload = trace_file(source) + output.write_text(json.dumps(payload, ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8") diff --git a/tools/research/build123dftc/b3ftc/_validate_worker.py b/tools/research/build123dftc/b3ftc/_validate_worker.py new file mode 100644 index 00000000..fd6371f6 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/_validate_worker.py @@ -0,0 +1,296 @@ +"""Isolated CAD worker; communicates only through an explicit JSON file.""" +from __future__ import annotations + +import argparse +import importlib.util +import json +import math +from pathlib import Path +import shutil +import traceback +import uuid + + +def _volume(shape): + if not _solid_count(shape): + from OCP.TopAbs import TopAbs_FACE + from OCP.TopExp import TopExp_Explorer + if TopExp_Explorer(shape, TopAbs_FACE).More(): + raise ValueError("volume result has faces but no closed solid") + return 0.0 + from OCP.BRepGProp import BRepGProp + from OCP.GProp import GProp_GProps + properties = GProp_GProps() + error = BRepGProp.VolumePropertiesGK_s(shape, properties, 1e-9, True, True) + if error < 0: + raise ValueError("Gauss-Kronrod volume integration failed") + return float(properties.Mass()) + + +def _area(shape): + from OCP.BRepGProp import BRepGProp + from OCP.BRepBuilderAPI import BRepBuilderAPI_Copy + from OCP.GeomAbs import GeomAbs_C1 + from OCP.GProp import GProp_GProps + from OCP.ShapeUpgrade import ShapeUpgrade_ShapeDivideContinuity + # Integration must respect C0 knot boundaries. Work on independent geometry + # so this numerical conditioning never changes the FTC or exported STEP. + copied = BRepBuilderAPI_Copy(shape, True, False).Shape() + divide = ShapeUpgrade_ShapeDivideContinuity(copied) + divide.SetSurfaceCriterion(GeomAbs_C1) + divide.SetBoundaryCriterion(GeomAbs_C1) + divide.SetPCurveCriterion(GeomAbs_C1) + divide.Perform() + measurement = divide.Result() + if measurement.IsNull(): + raise ValueError("surface integration continuity split produced no shape") + properties = GProp_GProps() + BRepGProp.SurfaceProperties_s(S=measurement, SProps=properties, Eps=1e-10, SkipShared=False) + return float(properties.Mass()) + + +def _solid_count(shape): + from OCP.TopAbs import TopAbs_SOLID + from OCP.TopExp import TopExp_Explorer + explorer = TopExp_Explorer(shape, TopAbs_SOLID) + count = 0 + while explorer.More(): + count += 1 + explorer.Next() + return count + + +def _read_step(step): + from OCP.BRepCheck import BRepCheck_Analyzer + from OCP.IFSelect import IFSelect_RetDone + from OCP.STEPControl import STEPControl_Reader + if not step.is_file(): + raise FileNotFoundError(f"reference STEP does not exist: {step}") + reader = STEPControl_Reader() + if reader.ReadFile(str(step)) != IFSelect_RetDone or reader.TransferRoots() == 0: + raise ValueError("reference STEP could not be read") + reference = reader.OneShape() + if reference.IsNull() or not BRepCheck_Analyzer(reference).IsValid() or not _solid_count(reference): + raise ValueError("reference STEP contains no valid solids") + from OCP.BRepClass3d import BRepClass3d_SolidClassifier + from OCP.TopAbs import TopAbs_SOLID, TopAbs_OUT + from OCP.TopExp import TopExp_Explorer + explorer = TopExp_Explorer(reference, TopAbs_SOLID) + while explorer.More(): + classifier = BRepClass3d_SolidClassifier(explorer.Current()) + classifier.PerformInfinitePoint(1e-7) + if classifier.State() != TopAbs_OUT: + raise ValueError("reference STEP solid orientation includes the infinite exterior") + explorer.Next() + return reference + + +def _compare_reference(shapes, step): + return _compare_shapes(shapes, _read_step(step)) + + +def _compare_shapes(shapes, reference): + from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut, BRepAlgoAPI_Fuse + from OCP.BRepCheck import BRepCheck_Analyzer + # Treat body groups as a geometric set. Fuse disjoint bodies too, avoiding double + # counting overlap when comparing a multi-body result to STEP assemblies. + actual = shapes[0] + for shape in shapes[1:]: + fusion = BRepAlgoAPI_Fuse(actual, shape) + fusion.Build() + if not fusion.IsDone(): + raise ValueError("could not combine actual bodies for comparison") + actual = fusion.Shape() + tolerance = _kernel_tolerance(actual, reference) + # Configure before the first Build: the two-shape constructor would already + # run the intersection and retain a pave filler computed at default tolerance. + missing = _cut(reference, actual, tolerance) + extra = _cut(actual, reference, tolerance) + for operation in (missing, extra): + if not operation.IsDone() or operation.Shape().IsNull(): + return {"reference_status": "error", "reference_error": "STEP symmetric difference failed", + "reference_boolean_fuzzy_tolerance": tolerance} + if not BRepCheck_Analyzer(operation.Shape()).IsValid(): + return {"reference_status": "error", "reference_error": "STEP symmetric difference produced invalid topology", + "reference_boolean_fuzzy_tolerance": tolerance} + return {"reference_status": "ok", "reference_volume": _volume(reference), + "reference_boolean_fuzzy_tolerance": tolerance, + "symmetric_difference_volume": abs(_volume(missing.Shape())) + abs(_volume(extra.Shape()))} + + +def _cut(left, right, tolerance): + from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut + try: + from OCP.TopTools import TopTools_ListOfShape as ShapeList + except ImportError: + from OCP.collections import List_TopoDS_Shape as ShapeList + arguments, tools = ShapeList(), ShapeList() + arguments.Append(left) + tools.Append(right) + operation = BRepAlgoAPI_Cut() + operation.SetArguments(arguments) + operation.SetTools(tools) + operation.SetNonDestructive(True) + operation.SetFuzzyValue(tolerance) + operation.Build() + return operation + + +def _kernel_tolerance(*shapes): + from OCP.BRep import BRep_Tool + from OCP.Precision import Precision + from OCP.TopAbs import TopAbs_VERTEX, TopAbs_EDGE + from OCP.TopExp import TopExp_Explorer + from OCP.TopoDS import TopoDS + tolerance = float(Precision.Confusion_s()) + for shape in shapes: + for kind, name in ((TopAbs_VERTEX, "Vertex"), (TopAbs_EDGE, "Edge")): + cast = getattr(TopoDS, name + "_s", None) or getattr(TopoDS, name) + explorer = TopExp_Explorer(shape, kind) + while explorer.More(): + value = float(BRep_Tool.Tolerance_s(cast(explorer.Current()))) + if not math.isfinite(value) or value < 0: + raise ValueError("invalid reference geometry tolerance") + tolerance = max(tolerance, value) + explorer.Next() + return tolerance + + +def _export_step(shapes, path, options=None): + from OCP.STEPControl import STEPControl_Writer, STEPControl_AsIs + from OCP.Interface import Interface_Static + from OCP.IFSelect import IFSelect_RetDone + writer = STEPControl_Writer() + options = options or {} + pcurves = options.get("write_pcurves", True) + precision = options.get("precision_mode", "AVERAGE") + modes = {"AVERAGE": 0, "GREATEST": 1, "LEAST": -1, "SESSION": 2} + if not isinstance(pcurves, bool) or precision not in modes: + raise ValueError("invalid source STEP export options") + # Honor the declared corpus export contract: spherical seams retain their + # UV curves; freeform sweeps can explicitly request rebuilding on import. + if not Interface_Static.SetIVal_s("write.surfacecurve.mode", int(pcurves)): + raise ValueError("could not configure STEP parameter-curve export") + if not Interface_Static.SetIVal_s("write.precision.mode", modes[precision]): + raise ValueError("could not configure STEP precision mode") + for shape in shapes: + if writer.Transfer(shape, STEPControl_AsIs) != IFSelect_RetDone: + raise ValueError("could not transfer actual geometry for external comparison") + if writer.Write(str(path)) != IFSelect_RetDone: + raise ValueError("could not export actual geometry for external comparison") + return {"write_pcurves": pcurves, "precision_mode": precision, + "rebuild_pcurves_on_import": not pcurves} + + +def _returned_shapes(value, placement=None): + """Extract world-space topology from the actual build result.""" + from simplecadapi import Solid, Part, Assembly, PartBuildResult, AssemblyBuildResult + from simplecadapi.product.placement import identity_placement + from OCP.BRepBuilderAPI import BRepBuilderAPI_Transform + from OCP.gp import gp_Trsf + if isinstance(value, (PartBuildResult, AssemblyBuildResult)): + value = value.value + if isinstance(value, Part): + value = value.body + if isinstance(value, Assembly): + parent = placement or identity_placement() + return [shape for component in value.components + for shape in _returned_shapes(component.item, parent.compose(component.placement))] + if isinstance(value, Solid): + if placement is None or placement == identity_placement(): + return [value.wrapped] + x, y, z, o = placement.x_axis, placement.y_axis, placement.z_axis, placement.origin + transform = gp_Trsf() + transform.SetValues(x[0], y[0], z[0], o[0], x[1], y[1], z[1], o[1], x[2], y[2], z[2], o[2]) + return [BRepBuilderAPI_Transform(value.wrapped, transform, True).Shape()] + raise ValueError("build() must return an actual Solid, Part or Assembly build result") + + +def run(ftc_path, staging_dir, reference_step=None, export_step=None, export_options=None): + import OCP + from OCP.Bnd import Bnd_Box + from OCP.BRepBndLib import BRepBndLib + from OCP.BRepCheck import BRepCheck_Analyzer + from OCP.TopoDS import TopoDS_Shape + # An isolated path keeps imports/artifacts away from original outputs and + # provides a fresh module/global BODIES namespace on every validation. + staged = staging_dir / (ftc_path.stem + "_" + uuid.uuid4().hex + ".py") + shutil.copyfile(ftc_path, staged) + spec = importlib.util.spec_from_file_location("ftc_validation_" + uuid.uuid4().hex, staged) + if spec is None or spec.loader is None: + raise ValueError("cannot import FTC module") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + build = getattr(module, "build", None) + if not callable(build): + raise ValueError("FTC module must define callable build()") + built = build() + bodies = getattr(module, "BODIES", None) + if not isinstance(bodies, (list, tuple)) or not bodies: + return {"status": "ok", "body_count": 0, "solid_count": 0, + "is_valid": False, "volume": None, "bbox": None} + for index, body in enumerate(bodies): + wrapped = getattr(body, "wrapped", None) + if not isinstance(wrapped, TopoDS_Shape) or wrapped.IsNull(): + raise ValueError(f"BODIES[{index}] is not actual nonempty CAD topology") + if _solid_count(wrapped) < 1: + raise ValueError(f"BODIES[{index}] contains no solid") + shapes = _returned_shapes(built) + if not shapes or len(shapes) != len(bodies): + raise ValueError("build() result body count does not match BODIES") + if any(shape.IsNull() or not _solid_count(shape) for shape in shapes): + raise ValueError("build() returned empty CAD topology") + if not all(body.wrapped.IsSame(shape) for body, shape in zip(bodies, shapes)): + from simplecadapi.kernel.ocp_export import make_compound_always + consistency = _compare_shapes(shapes, make_compound_always([body.wrapped for body in bodies])) + if (consistency["reference_status"] != "ok" or + consistency["symmetric_difference_volume"] > max(1e-7, abs(consistency["reference_volume"]) * 1e-7)): + raise ValueError("BODIES geometry does not match the actual build() result") + bounds = Bnd_Box() + for shape in shapes: + BRepBndLib.AddOptimal_s(shape, bounds, False, False) + volume = sum(_volume(shape) for shape in shapes) + low, high = bounds.CornerMin(), bounds.CornerMax() + bbox = [float(getattr(point, axis)()) for point in (low, high) for axis in "XYZ"] + if not math.isfinite(volume) or not all(map(math.isfinite, bbox)): + raise ValueError("nonfinite actual geometry metrics") + result = {"status": "ok", "body_count": len(bodies), + "solid_count": sum(_solid_count(shape) for shape in shapes), + "is_valid": all(BRepCheck_Analyzer(shape).IsValid() for shape in shapes), + "volume": volume, "area": sum(_area(shape) for shape in shapes), "bbox": bbox, + "build_kernel": getattr(OCP, "__version__", "unknown"), + "volume_method": "Gauss-Kronrod, epsilon=1e-9, closed shells, BSpline spans", + "area_method": "Independent geometry copy, C1 continuity spans, adaptive epsilon=1e-10"} + if reference_step is not None: + try: + result.update(_compare_reference(shapes, reference_step)) + except Exception as exc: + result.update(reference_status="error", reference_error=f"{type(exc).__name__}: {exc}") + if export_step is not None: + try: + result["reference_export_options"] = _export_step(shapes, export_step, export_options) + except Exception as exc: + result.update(reference_status="error", reference_error=f"{type(exc).__name__}: {exc}") + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--ftc", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--staging-dir", type=Path, required=True) + parser.add_argument("--reference-step", type=Path) + parser.add_argument("--export-step", type=Path) + parser.add_argument("--export-options", type=json.loads) + args = parser.parse_args() + try: + result = run(args.ftc, args.staging_dir, args.reference_step, args.export_step, args.export_options) + except BaseException as exc: + result = {"status": "build_error", "error": f"{type(exc).__name__}: {exc}", + "traceback": traceback.format_exc(limit=5)} + args.output.write_text(json.dumps(result, ensure_ascii=False, allow_nan=False) + "\n") + return 0 if result.get("status") == "ok" else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/research/build123dftc/b3ftc/emit.py b/tools/research/build123dftc/b3ftc/emit.py new file mode 100644 index 00000000..c1abdddb --- /dev/null +++ b/tools/research/build123dftc/b3ftc/emit.py @@ -0,0 +1,152 @@ +"""Deterministic FTC formatting and topology-fingerprint QL selectors. + +This module has no CAD dependency: generated programs use only SimpleCADAPI. +""" +from __future__ import annotations +import math +import re +from typing import Any, Mapping, Sequence + +ROLES = frozenset({'build', 'add', 'subtract', 'intersect', 'modify', 'pattern', 'annotate'}) + + +def fmt_num(value: float) -> str: + number = float(value) + if not math.isfinite(number): + raise ValueError('non-finite geometry parameter') + if abs(number) < 1e-12: + number = 0.0 + return format(number, '.15g') + + +def fmt_vec(vector: Sequence[float]) -> str: + return '(' + ', '.join(fmt_num(v) for v in vector) + (',' if len(vector) == 1 else '') + ')' + + +def fmt_literal(value: Any) -> str: + if value is None or isinstance(value, (bool, str)): + return repr(value) + if isinstance(value, (int, float)): + return fmt_num(value) + if isinstance(value, (list, tuple)): + return '[' + ', '.join(fmt_literal(v) for v in value) + ']' + if isinstance(value, Mapping): + return '{' + ', '.join(repr(k) + ': ' + fmt_literal(v) for k, v in value.items()) + '}' + raise ValueError(f'unsupported literal type: {type(value).__name__}') + + +class SlugAllocator: + def __init__(self) -> None: + self.counts: dict[str, int] = {} + + def allocate(self, name: str) -> str: + slug = re.sub('[^a-z0-9]+', '-', str(name).lower()).strip('-') or 'feature' + count = self.counts.get(slug, 0) + 1 + self.counts[slug] = count + return slug if count == 1 else f'{slug}-{count}' + + +def block_header(slug: str, role: str, tiers: Sequence[str] = ()) -> str: + if role not in ROLES: + raise ValueError(f'invalid FTC role: {role}') + return f" # ---- feature: {slug} ({', '.join([role, *tiers])}) ----" + + +def fingerprint_selector(fingerprints: Sequence[Mapping[str, Any]], kind: str, tolerance: float = 1e-4) -> str: + """Union individual fingerprint predicates; never select a wide bounding band. + + Each traced edge/face gets its own conjunction. This preserves a disjoint + selected set whose bounding box could otherwise include unrelated topology. + """ + predicates = [] + seen = set() + for fp in fingerprints: + if fp.get('kind', kind) != kind: + continue + terms = [] + geom_type = fp.get('geom_type') or fp.get('type') + if geom_type: + terms.append(f"ql.prop('geom.type', '==', {str(geom_type).upper()!r})") + if kind == 'solid' and fp.get('bbox') is not None: + for index, value in enumerate(fp['bbox']): + side, axis = ('min' if index < 3 else 'max'), 'xyz'[index % 3] + terms.extend([ + f"ql.prop('geom.bbox.{side}.{axis}', '>=', {fmt_num(float(value) - tolerance)})", + f"ql.prop('geom.bbox.{side}.{axis}', '<=', {fmt_num(float(value) + tolerance)})", + ]) + for name in ('center', 'normal'): + if kind == 'solid': + continue + values = fp.get(name) + if values is not None: + for axis, value in zip('xyz', values): + tolerance_here = 1e-5 if name == 'normal' else tolerance + value = round(float(value), 10) + terms.extend([ + f"ql.prop('geom.{name}.{axis}', '>=', {fmt_num(value - tolerance_here)})", + f"ql.prop('geom.{name}.{axis}', '<=', {fmt_num(value + tolerance_here)})", + ]) + for name in ('length', 'area', 'radius', 'volume'): + if kind == 'solid' and name != 'volume': + continue + if (kind == 'edge' and name == 'area') or (kind == 'face' and name == 'length'): + continue + if fp.get(name) is not None: + value = float(fp[name]) + delta = max(tolerance, abs(value) * 1e-8) + terms.extend([ + f"ql.prop('geom.{name}', '>=', {fmt_num(value - delta)})", + f"ql.prop('geom.{name}', '<=', {fmt_num(value + delta)})", + ]) + if not terms: + raise ValueError(f'{kind} selection lacks geometric fingerprints') + predicate = 'ql.and_(' + ', '.join(terms) + ')' + if predicate not in seen: + seen.add(predicate) + predicates.append(predicate) + if not predicates: + raise ValueError(f'{kind} selection is empty') + combined = predicates[0] if len(predicates) == 1 else 'ql.or_(' + ', '.join(predicates) + ')' + count = len([fp for fp in fingerprints if fp.get('kind', kind) == kind]) + limit = '' if kind == 'solid' else f'.take({count})' + return f'ql.{kind}s().where({combined}){limit}.exactly({count})' + + +def emit_module(stem: str, lines: Sequence[str], refs: Sequence[str], unsupported: Sequence[str], uses_ql: bool, solid_count: int = 1) -> str: + part_id = 'b3d-' + (re.sub('[^A-Za-z0-9._-]+', '-', stem).strip('-.') or 'part') + result = [f'"""FTC generated from build123d feature trace: {stem.replace(chr(34), chr(39))}."""', + '', 'from pathlib import Path', '', 'import simplecadapi as scad'] + if uses_ql: + result.append('from simplecadapi import ql') + result.extend(['', 'BODIES = None', '', '']) + if solid_count <= 1: + result.extend([f"@scad.part(id={part_id!r}, revision='1.0.0', project_root=Path(__file__).parent)", + 'def build() -> scad.Part:']) + else: + result.append('def _build_bodies():') + result.extend(lines) + for note in unsupported: + result.append(' # untranslated: ' + str(note).replace('\n', ' ')) + if refs: + result.extend([f' bodies = [_b for _group in [{", ".join(refs)}] for _b in _group]', + ' global BODIES', ' BODIES = list(bodies)', + ' return bodies[0]' if solid_count <= 1 else ' return bodies']) + else: + result.append(" raise RuntimeError('feature tree produced no solid')") + if solid_count > 1: + for index in range(solid_count): + result.extend(['', '', f"@scad.part(id={f'{part_id}-body-{index + 1}'!r}, revision='1.0.0', project_root=Path(__file__).parent)", + f'def _build_body_{index + 1}() -> scad.Part:', + f' return _build_bodies()[{index}]']) + result.extend(['', '', 'def build():', + ' parts = [' + ', '.join(f'_build_body_{i + 1}()' for i in range(solid_count)) + ']', + f" @scad.assemble(id={part_id!r}, revision='1.0.0', definitions=parts, project_root=Path(__file__).parent)", + ' def _build_assembly():', + ' # ---- feature: body-components (build) ----', + f' assembly = scad.make_assembly_rassembly(assembly_id={part_id!r})', + ' for index, item in enumerate(parts):', + " component_id = f'body-{index + 1}'", + ' assembly = scad.add_component_rassembly(assembly=assembly, item=item.value, component_id=component_id, placement=scad.identity_placement_rplacement())', + ' assembly = scad.ground_component_rassembly(assembly=assembly, component_id=component_id)', + ' return assembly', ' return _build_assembly()']) + return '\n'.join(result) + '\n' diff --git a/tools/research/build123dftc/b3ftc/geometry.py b/tools/research/build123dftc/b3ftc/geometry.py new file mode 100644 index 00000000..7cf96f89 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/geometry.py @@ -0,0 +1,224 @@ +"""Kernel-independent JSON descriptions of build123d profile geometry. + +The trace contains analytic curves and NURBS control data, never a saved BRep. +Coordinates are in the coordinate system of the actual feature input. +""" +from __future__ import annotations + +from enum import Enum +import math +from typing import Any + + +def vector(value: Any) -> list[float]: + if hasattr(value, "X"): + return [float(getattr(value, n)() if callable(getattr(value, n)) else getattr(value, n)) for n in "XYZ"] + if hasattr(value, "x"): + return [float(value.x), float(value.y), float(value.z)] + return [float(value.X()), float(value.Y()), float(value.Z())] + + +def plane(value: Any) -> dict[str, Any]: + return {"origin": vector(value.origin), "x_dir": vector(value.x_dir), + "y_dir": vector(value.y_dir), "normal": vector(value.z_dir)} + + +def location_matrix(value: Any) -> list[list[float]]: + trsf = value.wrapped.Transformation() + return [[float(trsf.Value(i, j)) for j in range(1, 5)] for i in range(1, 4)] + [[0., 0., 0., 1.]] + + +def serialize(value: Any) -> Any: + if value is None or isinstance(value, (str, bool, int, float)): + return value + if isinstance(value, Enum): + return value.name + if isinstance(value, dict): + return {str(k): serialize(v) for k, v in value.items()} + if isinstance(value, (list, tuple)): + return [serialize(v) for v in value] + name = type(value).__name__ + if name == "Plane": + return plane(value) + if name == "Axis": + return {"origin": vector(value.position), "direction": vector(value.direction)} + if name in {"Location", "Rotation", "Pos", "Rot"} or hasattr(value, "wrapped") and hasattr(value.wrapped, "Transformation"): + return {"matrix": location_matrix(value)} + if name == "Matrix": + return {"matrix": [[float(value.wrapped.Value(i, j)) for j in range(1, 5)] for i in range(1, 4)] + [[0., 0., 0., 1.]]} + if name == "Vector": + return vector(value) + if hasattr(value, "wrapped"): + return {"shape_type": name} + return {"type": name, "repr": repr(value)} + + +def metrics(shape: Any) -> dict[str, Any]: + from OCP.BRepGProp import BRepGProp + from OCP.GProp import GProp_GProps + shapes = shape if isinstance(shape, (list, tuple)) else [shape] + solids = [s for item in shapes if item is not None for s in item.solids()] + if not solids: + return {"volume": 0., "bbox": None, "solid_count": 0} + boxes = [s.bounding_box() for s in solids] + low = [min(vector(box.min)[i] for box in boxes) for i in range(3)] + high = [max(vector(box.max)[i] for box in boxes) for i in range(3)] + volumes, areas = [], [] + for solid in solids: + properties = GProp_GProps() + BRepGProp.VolumePropertiesGK_s(solid.wrapped, properties, 1e-9, True, True) + volumes.append(float(properties.Mass())) + areas.append(surface_area(solid.wrapped)) + return {"volume": sum(volumes), "volume_gk": sum(volumes), "area": sum(areas), "default_volume": sum(float(s.volume) for s in solids), "bbox": low + high, + "solid_count": len(solids)} + + +def surface_area(wrapped: Any) -> float: + """Integrate per smooth span on a geometry copy, preserving the source model. + + OCCT's adaptive surface integrator can miss rational spline knot breaks. + Splitting C0 boundaries/surfaces into C1 spans resolves those breaks before + integration. This temporary topology is used only for the numeric metric. + """ + from OCP.BRepBuilderAPI import BRepBuilderAPI_Copy + from OCP.ShapeUpgrade import ShapeUpgrade_ShapeDivideContinuity + from OCP.GeomAbs import GeomAbs_C1 + from OCP.BRepGProp import BRepGProp + from OCP.GProp import GProp_GProps + copied = BRepBuilderAPI_Copy(wrapped, True, False).Shape() + divider = ShapeUpgrade_ShapeDivideContinuity(copied) + divider.SetSurfaceCriterion(GeomAbs_C1) + divider.SetBoundaryCriterion(GeomAbs_C1) + divider.SetPCurveCriterion(GeomAbs_C1) + divider.Perform() + properties = GProp_GProps() + BRepGProp.SurfaceProperties_s(S=divider.Result(), SProps=properties, Eps=1e-10, SkipShared=False) + return float(properties.Mass()) + + +def fingerprint(shape: Any, parent: Any = None) -> dict[str, Any]: + from build123d import CenterOf + kind = type(shape).__name__.lower() + payload = {"kind": kind, "geom_type": shape.geom_type.name, + "center": vector(shape.center(CenterOf.MASS)) if kind in {"edge", "face"} else vector(shape.center()), + "bbox": vector(shape.bounding_box().min) + vector(shape.bounding_box().max)} + if kind in {"edge", "wire"}: + payload["length"] = float(shape.length) + payload["start"] = vector(shape.position_at(0)) + payload["mid"] = vector(shape.position_at(.5)) + payload["end"] = vector(shape.position_at(1)) + if kind == "face": + payload["area"] = float(shape.area) + if shape.geom_type.name == "PLANE": + try: + payload["normal"] = vector(shape.normal_at()) + except Exception: + pass + if parent is not None: + children = parent.edges() if kind == "edge" else parent.faces() if kind == "face" else parent.vertices() + for index, child in enumerate(children): + if child.wrapped.IsSame(shape.wrapped): + payload["index"] = index + break + return payload + + +def edge(value: Any) -> dict[str, Any]: + from OCP.BRepAdaptor import BRepAdaptor_Curve + adaptor = BRepAdaptor_Curve(value.wrapped) + kind = value.geom_type.name.lower() + first, last = adaptor.FirstParameter(), adaptor.LastParameter() + common = {"start": vector(value.position_at(0)), "end": vector(value.position_at(1)), + "parameter_range": [float(first), float(last)], "reversed": not value.is_forward} + if kind == "line": + return {"kind": "line", **common} + if kind == "circle": + circle = adaptor.Circle() + data = {"center": vector(circle.Location()), "radius": float(circle.Radius()), + "normal": vector(circle.Axis().Direction()), "x_dir": vector(circle.XAxis().Direction())} + if abs(last - first - 2 * math.pi) < 1e-7: + return {"kind": "circle", **common, **data} + return {"kind": "arc", "mid": vector(value.position_at(.5)), **common, **data} + if kind == "ellipse" and abs(last - first - 2 * math.pi) < 1e-7: + ellipse = adaptor.Ellipse() + return {"kind": "ellipse", **common, "center": vector(ellipse.Location()), + "major_radius": float(ellipse.MajorRadius()), "minor_radius": float(ellipse.MinorRadius()), + "x_dir": vector(ellipse.XAxis().Direction()), "y_dir": vector(ellipse.YAxis().Direction()), + "normal": vector(ellipse.Axis().Direction())} + if kind in {"bspline", "bezier", "ellipse", "parabola", "hyperbola"}: + # Segmentation preserves the exact trimmed curve, including NURBS weights. + # Conic arcs become exact rational BSplines rather than sampled polylines. + if kind not in {"bspline", "bezier"}: + from OCP.Geom import Geom_TrimmedCurve + from OCP.GeomConvert import GeomConvert + from OCP.BRep import BRep_Tool + curve = BRep_Tool.Curve_s(value.wrapped, first, last) + spline = GeomConvert.CurveToBSplineCurve_s(Geom_TrimmedCurve(curve, first, last)) + kind = "bspline" + else: + spline = adaptor.BSpline() if kind == "bspline" else adaptor.Bezier() + unclamped = kind == "bspline" and not spline.IsPeriodic() and (spline.Multiplicity(1) < spline.Degree()+1 or spline.Multiplicity(spline.NbKnots()) < spline.Degree()+1) + if unclamped or abs(first - spline.FirstParameter()) > 1e-9 or abs(last - spline.LastParameter()) > 1e-9: + spline = spline.Copy() + spline.Segment(first, last) + # Converted/segmented poles already describe exactly the edge extent. + common["parameter_range"] = [float(spline.FirstParameter()), float(spline.LastParameter())] + data = {"kind": kind, **common, "degree": spline.Degree(), + "poles": [vector(spline.Pole(i)) for i in range(1, spline.NbPoles() + 1)], + "weights": [float(spline.Weight(i)) for i in range(1, spline.NbPoles() + 1)]} + if kind == "bspline": + data.update(knots=[float(spline.Knot(i)) for i in range(1, spline.NbKnots() + 1)], + multiplicities=[spline.Multiplicity(i) for i in range(1, spline.NbKnots() + 1)], + periodic=spline.IsPeriodic()) + return data + # Conics are kept analytic as a full parameterized curve description. + if kind in {"parabola", "hyperbola"}: + conic = adaptor.Parabola() if kind == "parabola" else adaptor.Hyperbola() + data = {"kind": kind, **common, "center": vector(conic.Location()), + "x_dir": vector(conic.XAxis().Direction()), "normal": vector(conic.Axis().Direction())} + if kind == "parabola": + data["focal"] = float(conic.Focal()) + else: + data.update(major_radius=float(conic.MajorRadius()), minor_radius=float(conic.MinorRadius())) + return data + raise ValueError(f"Unsupported profile curve: {value.geom_type.name}") + + +def wire(value: Any) -> dict[str, Any]: + from build123d import Edge + from OCP.BRepTools import BRepTools_WireExplorer + explorer = BRepTools_WireExplorer(value.wrapped) + edges = [] + while explorer.More(): + edges.append(edge(Edge(explorer.Current()))) + explorer.Next() + return {"edges": edges, "closed": bool(value.is_closed)} + + +def profile(value: Any) -> dict[str, Any]: + from build123d import Face, Plane, Vertex, Wire + if isinstance(value, Vertex): + return {"kind": "vertex", "point": vector(value.center())} + if isinstance(value, Wire): + value = Face(value) + if not isinstance(value, Face): + raise ValueError(f"A planar profile was expected, got {type(value).__name__}") + frame = Plane(value) + return {"kind": "face", **plane(frame), + "wires": [wire(value.outer_wire())] + [wire(w) for w in value.inner_wires()]} + + +def path(value: Any) -> dict[str, Any]: + from build123d import Edge, Wire + if isinstance(value, Edge): + return {"edges": [edge(value)], "closed": bool(value.is_closed)} + if not isinstance(value, Wire): + value = Wire(value.edges()) + result = wire(value) + try: + frame = value.find_plane() + if frame is not None: + result.update(planar=True, **plane(frame)) + except Exception: + pass + return result diff --git a/tools/research/build123dftc/b3ftc/profiles.py b/tools/research/build123dftc/b3ftc/profiles.py new file mode 100644 index 00000000..2fe77107 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/profiles.py @@ -0,0 +1,258 @@ +"""Exact profile reconstruction through native sketch/curve APIs. + +Planar input curves are transcribed into a local sketch, including rational +B-splines and ellipses. Nonplanar sweep paths remain geometry-tier wires. +No tessellation or final-body boundary reconstruction is used. +""" +from __future__ import annotations +import math +from typing import Any, Mapping, Sequence +from .emit import fmt_literal, fmt_num, fmt_vec + + +def dot(a, b): + return sum(float(x) * float(y) for x, y in zip(a, b)) + + +def cross(a, b): + return (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]) + + +def unit(a): + length = math.sqrt(dot(a, a)) + if length < 1e-12: + raise ValueError('degenerate frame axis') + return tuple(float(x) / length for x in a) + + +def frame(profile): + normal = unit(profile.get('normal', (0, 0, 1))) + u = profile.get('u') or profile.get('x_dir') + if u is None: + seed = (0, 1, 0) if abs(normal[0]) > .8 else (1, 0, 0) + u = unit(cross(seed, normal)) + else: + u = unit(u) + v = unit(profile.get('v') or profile.get('y_dir') or cross(normal, u)) + return profile.get('origin', (0, 0, 0)), u, v, normal + + +def circumcenter(a, b, c): + determinant = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1])) + if abs(determinant) < 1e-15: + raise ValueError('arc points are collinear') + squared = [dot(p, p) for p in (a, b, c)] + return ((squared[0] * (b[1] - c[1]) + squared[1] * (c[1] - a[1]) + squared[2] * (a[1] - b[1])) / determinant, + (squared[0] * (c[0] - b[0]) + squared[1] * (a[0] - c[0]) + squared[2] * (b[0] - a[0])) / determinant) + + +def oriented_spline(edge): + """Align basis poles with traced edge traversal before binding endpoints. + + OCCT adaptor poles retain increasing parameter order even when a wire + traverses the edge backwards. Swapping only its endpoint refs distorts + cubic and higher-order curves, so reverse the entire exact basis. + """ + poles = edge.get('poles') or edge.get('control_points') + start, end = edge.get('start'), edge.get('end') + if not poles or start is None or end is None or math.dist(start, end) < 1e-9: + return edge + if math.dist(start, poles[-1]) > 1e-7 or math.dist(end, poles[0]) > 1e-7: + return edge + changed = dict(edge, poles=list(reversed(poles))) + if edge.get('weights'): + changed['weights'] = list(reversed(edge['weights'])) + if edge.get('knots'): + total = edge['knots'][0] + edge['knots'][-1] + changed['knots'] = [total - knot for knot in reversed(edge['knots'])] + if edge.get('multiplicities'): + changed['multiplicities'] = list(reversed(edge['multiplicities'])) + return changed + + +class Sketch: + def __init__(self, name, profile): + self.name = name + self.origin, self.u, self.v, self.normal = frame(profile) + plane_expr = "{'origin': " + fmt_vec(self.origin) + ", 'x_axis': " + fmt_vec(self.u) + ", 'y_axis': " + fmt_vec(self.v) + "}" + self.lines = [f" {name} = scad.make_sketch_rsketch(name={name!r}, plane={plane_expr})"] + self.points = {} + self.counter = 0 + self.entities = 0 + self.snapshot_entities = [] + + def local(self, point): + delta = [float(x) - float(y) for x, y in zip(point, self.origin)] + if abs(dot(delta, self.normal)) > 1e-5: + raise ValueError('nonplanar curve cannot be represented by sketch') + return dot(delta, self.u), dot(delta, self.v) + + def point(self, coordinates): + key = tuple(round(x, 9) for x in coordinates) + if key not in self.points: + self.counter += 1 + point_id = f'p{self.counter}' + self.points[key] = point_id + self.lines.append(f' {self.name} = scad.add_point_rsketch(sketch={self.name}, point_id={point_id!r}, x={fmt_num(coordinates[0])}, y={fmt_num(coordinates[1])})') + self.snapshot_entities.append({'id': point_id, 'kind': 'point', 'xy': list(coordinates)}) + return self.points[key] + + def entity(self, edge): + self.entities += 1 + name = f'e{self.entities}' + prefix = f' {self.name} = scad.' + base = f'sketch={self.name}, entity_id={name!r}' + kind = edge['kind'].lower() + if kind == 'line': + a, b = self.point(self.local(edge['start'])), self.point(self.local(edge['end'])) + self.lines.append(prefix + f'add_line_rsketch({base}, start={a!r}, end={b!r})') + self.snapshot_entities.append({'id': name, 'kind': 'line', 'start': a, 'end': b}) + elif kind in ('arc', 'arc3') or (kind == 'circle' and edge.get('mid') is not None): + a, b, c = [self.local(edge[x]) for x in ('start', 'mid', 'end')] + center = circumcenter(a, b, c) + angles = [math.atan2(p[1] - center[1], p[0] - center[0]) for p in (a, b, c)] + if (angles[1] - angles[0]) % (2 * math.pi) > (angles[2] - angles[0]) % (2 * math.pi): + a, c = c, a + start, end, center_ref = self.point(a), self.point(c), self.point(center) + self.lines.append(prefix + f'add_arc_rsketch({base}, start={start!r}, end={end!r}, center={center_ref!r})') + self.snapshot_entities.append({'id': name, 'kind': 'arc', 'start': start, 'end': end, 'center': center_ref}) + elif kind == 'circle': + center = self.point(self.local(edge['center'])) + self.lines.append(prefix + f'add_circle_rsketch({base}, center={center!r}, radius={fmt_num(edge["radius"])})') + self.snapshot_entities.append({'id': name, 'kind': 'circle', 'center': center, 'radius': edge['radius']}) + elif kind == 'ellipse': + if edge.get('trimmed'): + raise ValueError('trimmed ellipse requires exact trimmed B-spline data') + center3 = edge['center'] + x_dir = edge.get('x_dir') or self.u + y_dir = edge.get('y_dir') or cross(edge.get('normal', self.normal), x_dir) + major3 = [c + edge['major_radius'] * d for c, d in zip(center3, x_dir)] + minor3 = [c + edge['minor_radius'] * d for c, d in zip(center3, y_dir)] + center, major, minor = [self.point(self.local(p)) for p in (center3, major3, minor3)] + self.lines.append(prefix + f'add_ellipse_rsketch({base}, center={center!r}, major_point={major!r}, minor_point={minor!r})') + self.snapshot_entities.append({'id': name, 'kind': 'ellipse', 'center': center, 'major_point': major, 'minor_point': minor}) + elif kind in ('bspline', 'bezier'): + edge = oriented_spline(edge) + poles = edge.get('poles') or edge.get('control_points') + if not poles: + raise ValueError('B-spline poles missing') + a = self.point(self.local(edge.get('start', poles[0]))) + b = self.point(self.local(edge.get('end', poles[-1]))) + degree = int(edge.get('degree', len(poles) - 1 if kind == 'bezier' else 3)) + knots = edge.get('knots', [0, 1] if kind == 'bezier' else None) + mults = edge.get('multiplicities', [degree + 1, degree + 1] if kind == 'bezier' else None) + self.lines.append(prefix + f'add_bspline_rsketch({base}, start={a!r}, end={b!r}, control_points={fmt_literal([self.local(p) for p in poles])}, degree={degree}, knots={fmt_literal(knots)}, multiplicities={fmt_literal(mults)}, weights={fmt_literal(edge.get("weights"))}, periodic={bool(edge.get("periodic", False))!r})') + self.snapshot_entities.append({'id': name, 'kind': 'bspline', 'start': a, 'end': b, + 'control_points': [self.local(p) for p in poles], 'degree': degree, + 'knots': knots, 'multiplicities': mults, 'weights': edge.get('weights'), 'periodic': edge.get('periodic', False)}) + else: + raise ValueError(f'unsupported exact curve kind: {kind}') + + +def _polygon_loops(profile, wires, name, snapshots): + """Compact native sketch construction for a large set of closed polygons.""" + sketches = [Sketch(f'{name}_loop{i}_sketch', profile) for i in range(len(wires))] + points = [] + for sketch, wire in zip(sketches, wires): + edges = wire['edges'] + if any(edge['kind'] != 'line' or math.dist(edge['end'], following['start']) > 1e-7 + for edge, following in zip(edges, edges[1:] + edges[:1])): + return None + points.append([sketch.local(edge['start']) for edge in edges]) + if snapshots is not None: + for sketch, wire in zip(sketches, wires): + edges = wire['edges'] + for edge in edges: + sketch.entity(edge) + snapshots.append({'name': sketch.name, 'entities': sketch.snapshot_entities, + 'closed': True, 'compact': True, + 'plane': {'origin': list(sketch.origin), 'x_axis': list(sketch.u), 'y_axis': list(sketch.v)}}) + origin, u, v, normal = frame(profile) + plane_expr = "{'origin': " + fmt_vec(origin) + ", 'x_axis': " + fmt_vec(u) + ", 'y_axis': " + fmt_vec(v) + "}" + data, refs = name + '_polygon_points', name + '_loop_wires' + lines = [f' {data} = [', *[f' {fmt_literal(loop)},' for loop in points], ' ]', + f' {refs} = []', f' for _loop_index, _points in enumerate({data}):', + f' _loop_sketch = scad.make_sketch_rsketch(name={name!r} + f"_loop{{_loop_index}}_sketch", plane={plane_expr})', + ' for _point_index, (_x, _y) in enumerate(_points):', + ' _loop_sketch = scad.add_point_rsketch(sketch=_loop_sketch, point_id=f"p{_point_index + 1}", x=_x, y=_y)', + ' for _edge_index in range(len(_points)):', + ' _loop_sketch = scad.add_line_rsketch(sketch=_loop_sketch, entity_id=f"e{_edge_index + 1}", start=f"p{_edge_index + 1}", end=f"p{(_edge_index + 1) % len(_points) + 1}")', + f' {refs}.append(scad.make_wire_from_sketch_rwire(sketch=_loop_sketch, profile=0))'] + output = name + '_face' + lines.append(f' {output} = scad.make_face_from_wires_rface(outer_wire={refs}[0], inner_wires={refs}[1:], normal={fmt_vec(normal)})') + return lines, output + + +def emit_profile(profile: Mapping[str, Any], name: str, *, as_wire: bool = False, snapshots=None): + """Return source lines + face/wire expression; outer-first wire ordering.""" + wires = profile.get('wires') or [{'edges': profile.get('edges', [])}] + if not wires or not wires[0].get('edges'): + raise ValueError('empty profile') + if as_wire and len(wires) > 1: + raise ValueError('a wire section cannot represent multiple disconnected loops') + if not as_wire and len(wires) > 1 and sum(len(wire.get('edges', [])) for wire in wires) > 256: + # A many-hole face can exceed libslvs' per-system unknown limit even + # without constraints. Promote each supplied loop in its own small + # sketch, then construct the same face from all its exact wires. + if all(wire.get('edges') and all(edge['kind'] == 'line' for edge in wire['edges']) for wire in wires): + compact = _polygon_loops(profile, wires, name, snapshots) + if compact is not None: + return compact + lines, refs = [], [] + for index, wire in enumerate(wires): + loop_lines, ref = emit_profile({**profile, 'wires': [wire]}, f'{name}_loop{index}', + as_wire=True, snapshots=snapshots) + lines.extend(loop_lines) + refs.append(ref) + output = name + '_face' + lines.append(f' {output} = scad.make_face_from_wires_rface(outer_wire={refs[0]}, inner_wires=[{", ".join(refs[1:])}], normal={fmt_vec(frame(profile)[3])})') + return lines, output + sketch = Sketch(name + '_sketch', profile) + profile_ids = [] + for wire in wires: + if not wire.get('edges'): + raise ValueError('empty inner profile') + profile_ids.append(f'e{sketch.entities + 1}') + for edge in wire['edges']: + sketch.entity(edge) + if snapshots is not None: + snapshots.append({'name': sketch.name, 'entities': sketch.snapshot_entities, + 'closed': wires[0].get('closed', not as_wire), + 'plane': {'origin': list(sketch.origin), 'x_axis': list(sketch.u), 'y_axis': list(sketch.v)}}) + output = name + ('_wire' if as_wire else '_face') + api = 'make_wire_from_sketch_rwire' if as_wire else 'make_face_from_sketch_rface' + outer = '0' if len(wires) == 1 else repr(profile_ids[0]) + holes = '' if len(wires) == 1 else f', inner_profiles={profile_ids[1:]!r}' + sketch.lines.append(f' {output} = scad.{api}(sketch={sketch.name}, profile={outer}{holes})') + return sketch.lines, output + + +def emit_path(path: Mapping[str, Any], name: str, *, snapshots=None): + if path.get('normal') is not None and path.get('planar', True): + return emit_profile(path, name, as_wire=True, snapshots=snapshots) + lines, edges = [], [] + path_edges = path.get('edges') or [edge for wire in path.get('wires', []) for edge in wire.get('edges', [])] + for index, edge in enumerate(path_edges): + ref = f'{name}_edge{index}' + kind = edge['kind'] + if kind == 'line': + expression = f'scad.make_line_redge(start={fmt_vec(edge["start"])}, end={fmt_vec(edge["end"])})' + elif kind in ('arc', 'arc3'): + expression = f'scad.make_three_point_arc_redge(start={fmt_vec(edge["start"])}, middle={fmt_vec(edge["mid"])}, end={fmt_vec(edge["end"])})' + elif kind == 'circle': + expression = f'scad.make_circle_redge(center={fmt_vec(edge["center"])}, radius={fmt_num(edge["radius"])}, normal={fmt_vec(edge.get("normal", (0, 0, 1)))})' + elif kind in ('bspline', 'bezier'): + edge = oriented_spline(edge) + degree = int(edge.get('degree', len(edge['poles']) - 1 if kind == 'bezier' else 3)) + expression = (f'scad.make_spline_redge(control_points={fmt_literal(edge["poles"])}, degree={degree}, ' + f'knots={fmt_literal(edge.get("knots"))}, multiplicities={fmt_literal(edge.get("multiplicities"))}, ' + f'weights={fmt_literal(edge.get("weights"))}, periodic={bool(edge.get("periodic", False))!r})') + else: + raise ValueError(f'unsupported nonplanar path curve: {kind}') + lines.append(f' {ref} = {expression}') + edges.append(ref) + if not edges: + raise ValueError('empty sweep path') + output = name + '_wire' + lines.append(f' {output} = scad.make_wire_from_edges_rwire(edges=[{", ".join(edges)}])') + return lines, output diff --git a/tools/research/build123dftc/b3ftc/replay.py b/tools/research/build123dftc/b3ftc/replay.py new file mode 100644 index 00000000..3c903688 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/replay.py @@ -0,0 +1,552 @@ +"""Translate a portable build123d operation trace into explicit FTC dataflow. + +Only recorded feature inputs are reconstructed. Unknown operations block their +own dependent chain instead of being replaced by final-result geometry. +""" +from __future__ import annotations +import math +import re +from typing import Any, Mapping +from .emit import SlugAllocator, block_header, emit_module, fingerprint_selector, fmt_literal, fmt_num, fmt_vec +from .profiles import cross, dot, emit_path, emit_profile, frame, unit + + +def _named(parameters, *names, default=None): + for name in names: + if name in parameters and parameters[name] is not None: + return parameters[name] + return default + + +def _variable(name): + return 'body_' + re.sub('[^a-zA-Z0-9_]', '_', str(name)) + + +def _axis(parameters): + value = parameters.get('axis', (0, 0, 1)) + if isinstance(value, dict): + return value.get('direction', (0, 0, 1)), value.get('origin', (0, 0, 0)) + return value, parameters.get('origin', (0, 0, 0)) + + +def _profiles(step): + profiles = step.get('profiles') or [step.get('profile')] + holes = step.get('inner_wires') or [] + if holes and len(profiles) == 1 and profiles[0]: + profile = dict(profiles[0]) + wires = list(profile.get('wires', [])) + for hole in holes: + wires.extend(hole.get('wires', [hole]) if isinstance(hole, dict) else []) + profile['wires'] = wires + profiles = [profile] + return profiles + + +def _matrix_operations(matrix): + """Decompose an affine matrix into local scale, rotation, translation.""" + if isinstance(matrix, dict): + matrix = matrix.get('matrix') + if len(matrix) == 16 and not isinstance(matrix[0], (list, tuple)): + matrix = [matrix[i:i + 4] for i in range(0, 16, 4)] + columns = [tuple(float(matrix[i][j]) for i in range(3)) for j in range(3)] + scales = [math.sqrt(dot(c, c)) for c in columns] + if min(scales) < 1e-12: + raise ValueError('singular affine transform') + axes = [tuple(x / scale for x in column) for column, scale in zip(columns, scales)] + if any(abs(dot(axes[i], axes[j])) > 1e-8 for i in range(3) for j in range(i + 1, 3)): + raise ValueError('affine shear cannot be represented by native scale/rotation') + if dot(cross(axes[0], axes[1]), axes[2]) < 0: + scales[0] = -scales[0] + axes[0] = tuple(-x for x in axes[0]) + r = [[axes[j][i] for j in range(3)] for i in range(3)] + cosine = max(-1., min(1., (r[0][0] + r[1][1] + r[2][2] - 1) / 2)) + angle = math.acos(cosine) + if angle < 1e-9: + axis = (0, 0, 1) + elif abs(angle - math.pi) < 1e-7: + diagonal = [max(0., (r[i][i] + 1) / 2) for i in range(3)] + pivot = max(range(3), key=lambda i: diagonal[i]) + axis_list = [0., 0., 0.] + axis_list[pivot] = math.sqrt(diagonal[pivot]) + for j in range(3): + if j != pivot: + axis_list[j] = (r[pivot][j] + r[j][pivot]) / (4 * axis_list[pivot]) + axis = unit(axis_list) + else: + axis = unit((r[2][1] - r[1][2], r[0][2] - r[2][0], r[1][0] - r[0][1])) + return scales, axis, math.degrees(angle), tuple(float(matrix[i][3]) for i in range(3)) + + +class TraceReplayer: + def __init__(self, trace: Mapping[str, Any], stem: str, constraints_mode: bool = False): + self.trace = trace + self.stem = stem + self.lines = [] + self.variables = {} + self.steps = {} + self.unsupported = list(trace.get('unsupported', [])) + self.slugs = SlugAllocator() + self.feature_count = 0 + self.uses_ql = False + self.snapshots = [] + self.constraints_mode = constraints_mode + self.constraint_reports = [] + + def profile(self, profile, name, as_wire=False): + if profile.get('kind') == 'vertex': + if not as_wire: + raise ValueError('vertex cannot be a solid profile') + output = name + '_vertex' + self.lines.append(f' {output} = scad.make_point_rvertex({", ".join(f"{axis}={fmt_num(x)}" for axis, x in zip("xyz", profile["point"]))})') + return output + lines, expression = emit_profile(profile, name, as_wire=as_wire, snapshots=self.snapshots) + self.lines.extend(lines) + return expression + + def source(self, step): + ids = step.get('inputs', []) + if isinstance(ids, str): + ids = [ids] + missing = [ref for ref in ids if ref not in self.variables] + if missing: + raise ValueError(f'input feature unavailable: {missing}') + return [self.variables[ref] for ref in ids] + + def build_step(self, step): + op = step['op'].lower() + p = step.get('parameters') or step.get('params') or {} + ident = step.get('id', f's{self.feature_count + 1}') + var = _variable(ident) + inputs = self.source(step) + create = op in {'box', 'cylinder', 'cone', 'sphere', 'torus', 'extrude', 'revolve', 'loft', 'sweep', 'sew_solid', 'extrude_linear', 'extrude_linear_with_rotation', 'extrude_taper', 'extrude_twist', 'extrude_until', 'sweep_multi'} + role = 'build' if create else {'union': 'add', 'fuse': 'add', 'cut': 'subtract', 'intersect': 'intersect', 'compound': 'pattern'}.get(op, 'modify') + tiers = ['profile=geometry'] if op in {'extrude', 'revolve', 'loft', 'sweep', 'sew_solid', 'extrude_linear', 'extrude_linear_with_rotation', 'torus', 'extrude_taper', 'extrude_twist', 'extrude_until', 'sweep_multi'} else [] + if op in {'sweep', 'sweep_multi'}: + tiers.append('path=geometry') + self.lines.append(block_header(self.slugs.allocate(op), role, tiers)) + if op in {'box', 'cylinder', 'cone', 'sphere', 'torus'}: + self.primitive(op, p, var) + elif op in {'extrude', 'extrude_linear'}: + profiles = _profiles(step) + if not all(profiles): + raise ValueError('extrusion profile missing') + direction = _named(p, 'direction', 'vector', 'dir', default=(0, 0, 1)) + distance = _named(p, 'distance', 'amount', 'height') + if distance is None: + distance = math.sqrt(dot(direction, direction)) + if distance < 0: + direction = [-float(x) for x in direction] + distance = -distance + refs = [self.profile(profile, f'{var}_profile{i}') for i, profile in enumerate(profiles)] + self.lines.append(f' {var} = [scad.extrude_rsolid(profile=_profile, direction={fmt_vec(direction)}, distance={fmt_num(distance)}) for _profile in [{", ".join(refs)}]]') + elif op in {'extrude_taper', 'extrude_until', 'extrude_twist', 'extrude_linear_with_rotation'}: + refs = [self.profile(profile, f'{var}_profile{i}') for i, profile in enumerate(_profiles(step))] + if op == 'extrude_taper': + vector = _named(p, 'direction', 'vector', default=(0, 0, 1)) + expression = f'scad.extrude_taper_rsolid(profile=_profile, vector={fmt_vec(vector)}, taper={fmt_num(p["taper"])}, flip_inner={bool(p.get("flip_inner", True))!r})' + elif op == 'extrude_until': + if not inputs: + raise ValueError('until extrusion target missing') + target = f'[_b for _group in [{", ".join(inputs)}] for _b in _group]' + expression = f'scad.extrude_until_rsolid(profile=_profile, target={target}, direction={fmt_vec(p.get("direction", (0, 0, 1)))}, until={str(p.get("until", "NEXT"))!r})' + else: + direction = _named(p, 'normal', 'direction', 'vector', default=(0, 0, 1)) + distance = math.sqrt(dot(direction, direction)) + origin = list(_named(p, 'center', 'origin', default=(0, 0, 0))) + if len(origin) == 2: + origin.append(0) + expression = f'scad.twisted_sweep_rsolid(profile=_profile, distance={fmt_num(distance)}, twist_angle={fmt_num(_named(p, "angle", "twist_angle", default=0))}, axis={fmt_vec(direction)}, origin={fmt_vec(origin)}, guide_radius=1)' + self.lines.append(f' {var} = [{expression} for _profile in [{", ".join(refs)}]]') + elif op == 'revolve': + profiles = _profiles(step) + refs = [self.profile(profile, f'{var}_profile{i}') for i, profile in enumerate(profiles)] + axis, origin = _axis(p) + angle = _named(p, 'angle', 'arc', 'revolution_arc', default=360) + if angle < 0: + angle, axis = -angle, [-float(x) for x in axis] + self.lines.append(f' {var} = [scad.revolve_rsolid(profile=_profile, axis={fmt_vec(axis)}, angle={fmt_num(angle)}, origin={fmt_vec(origin)}) for _profile in [{", ".join(refs)}]]') + elif op == 'loft': + profiles = step.get('profiles') or [] + refs = [self.profile(profile, f'{var}_section{i}', as_wire=True) for i, profile in enumerate(profiles)] + if len(refs) < 2: + raise ValueError('loft needs at least two recorded sections') + self.lines.append(f' {var} = [scad.loft_rsolid(profiles=[{", ".join(refs)}], ruled={bool(p.get("ruled", False))!r})]') + elif op == 'sew_solid': + if step.get('geometry_error'): + raise ValueError(step['geometry_error']) + profiles = step.get('profiles') or [] + if not profiles: + raise ValueError('solid shell requires recorded planar faces') + refs = [self.profile(profile, f'{var}_face{i}') for i, profile in enumerate(profiles)] + self.lines.append(f' {var}_shell = scad.sew_faces_rshell(faces=[{", ".join(refs)}])') + self.lines.append(f' {var} = [scad.make_solid_from_shell_rsolid(shell={var}_shell)]') + elif op in {'sweep', 'sweep_multi'}: + profiles = _profiles(step) + path = step.get('path') + if not path: + raise ValueError('sweep path missing') + path_lines, path_expr = emit_path(path, var + '_path', snapshots=self.snapshots) + self.lines.extend(path_lines) + refs = ([self.profile(profile, f'{var}_profile{i}') for i, profile in enumerate(profiles)] + if op == 'sweep_multi' or not any(len(profile.get('wires', [])) > 1 for profile in profiles) + else []) + frenet = bool(_named(p, 'is_frenet', 'frenet', default=False)) + if op == 'sweep_multi': + binormal = p.get('binormal') + if isinstance(binormal, dict): + raise ValueError('multisection sweep binormal wire missing from portable trace') + self.lines.append(f' {var} = [scad.sweep_multisection_rsolid(profiles=[{", ".join(refs)}], path={path_expr}, is_frenet={frenet!r}, binormal={fmt_literal(binormal)})]') + else: + if p.get('mode') is not None or str(p.get('transition', 'TRANSFORMED')) != 'TRANSFORMED': + raise ValueError('sweep mode/transition needs a native advanced sweep operator') + if any(len(profile.get('wires', [])) > 1 for profile in profiles): + pieces = [] + for index, profile in enumerate(profiles): + loops = [self.profile({**profile, 'wires': [wire]}, f'{var}_loop{index}_{i}') + for i, wire in enumerate(profile['wires'])] + outer = var + f'_outer{index}' + self.lines.append(f' {outer} = [scad.sweep_rsolid(profile={loops[0]}, path={path_expr}, is_frenet={frenet!r})]') + tools = ', '.join(f'scad.sweep_rsolid(profile={loop}, path={path_expr}, is_frenet={frenet!r})' for loop in loops[1:]) + pieces.append(f'scad.boolean_rsolidlist(left={outer}, right=[{tools}], operation="cut")') + self.lines.append(f' {var} = [_b for _group in [{", ".join(pieces)}] for _b in _group]') + else: + self.lines.append(f' {var} = [scad.sweep_rsolid(profile=_profile, path={path_expr}, is_frenet={frenet!r}) for _profile in [{", ".join(refs)}]]') + elif op == 'component': + if len(inputs) != 1: + raise ValueError('component requires one parent feature') + fingerprint = p.get('fingerprint', {}) + if fingerprint.get('bbox') is not None: + self.uses_ql = True + selector = fingerprint_selector([fingerprint], 'solid') + self.lines.append(f' {var} = {selector}.resolve({inputs[0]})') + else: + self.lines.append(f' {var} = [{inputs[0]}[{int(p["index"])}]]') + elif op in {'compound', 'copy', 'clean'}: + self.lines.append(f' {var} = [ _b for _group in [{", ".join(inputs)}] for _b in _group ]') + elif op in {'union', 'fuse', 'cut', 'intersect'}: + if not inputs: + raise ValueError('boolean inputs missing') + if len(inputs) == 1: + self.lines.append(f' {var} = list({inputs[0]})') + elif op == 'cut': + tools = f'[_b for _group in [{", ".join(inputs[1:])}] for _b in _group]' + self.lines.append(f' {var} = scad.boolean_rsolidlist(left={inputs[0]}, right={tools}, operation="cut")') + elif op == 'intersect': + self.lines.append(f' {var} = list({inputs[0]})') + for group in inputs[1:]: + self.lines.append(f' {var} = scad.boolean_rsolidlist(left={var}, right={group}, operation="intersect")') + else: + groups = step.get('result_groups') + if groups: + values = [] + for group in groups: + group_refs = [self.variables[x] for x in group] + values.append(f'scad.union_rsolid([{", ".join(group_refs)}], tracking_policy="graph")' if len(group_refs) > 1 else f'{group_refs[0]}[0]') + self.lines.append(f' {var} = [{", ".join(values)}]') + elif step.get('result', {}).get('solid_count', 1) > 1: + raise ValueError('disconnected union requires recorded connected operand groups') + else: + self.lines.append(f' {var} = [scad.union_rsolid([{", ".join(inputs)}], tracking_policy="graph")]') + elif op in {'fillet', 'chamfer'}: + selector = fingerprint_selector(step.get('selection', []), 'edge') + self.uses_ql = True + if len(inputs) != 1: + raise ValueError('blend requires one parent feature') + if op == 'fillet': + extras = f'radius={fmt_num(p["radius"])}' + else: + extras = f'distance={fmt_num(_named(p, "length", "distance", "length1"))}' + second = _named(p, 'length2', 'distance2') + if second is not None and abs(float(second) - float(_named(p, 'length', 'distance', 'length1'))) > 1e-9: + extras += ', angle=' + fmt_num(math.degrees(math.atan2(float(second), float(_named(p, 'length', 'distance', 'length1'))))) + direction = p.get('reference_direction') + if direction is None: + if p.get('reference_directions'): + raise ValueError('per-edge chamfer reference normals vary; the native operator requires one reference direction') + raise ValueError('asymmetric chamfer requires reference-face normal') + extras += ', reference_direction=' + fmt_vec(direction) + groups = step.get('component_selections') + if groups is not None: + self.lines.append(f' {var} = []') + for index, selection in enumerate(groups): + body = f'{inputs[0]}[{index}]' + if selection: + local = fingerprint_selector(selection, 'edge') + self.lines.append(f' {var}.append(scad.{op}_rsolid(solid={body}, edges={local}, {extras}))') + else: + self.lines.append(f' {var}.append({body})') + elif self.steps[step['inputs'][0]].get('result', {}).get('solid_count', 1) > 1: + raise ValueError('multi-body blend requires per-component selections') + else: + self.lines.append(f' {var} = [scad.{op}_rsolid(solid=_b, edges={selector}, {extras}) for _b in {inputs[0]}]') + elif op == 'draft': + if len(inputs) != 1: + raise ValueError('draft requires one parent feature') + selector = fingerprint_selector(step.get('selection', []), 'face') + self.uses_ql = True + plane = p.get('neutral_plane') or p.get('plane') or {} + angle = _named(p, 'angle', 'draft_angle') + if angle is None or not isinstance(plane, dict): + raise ValueError('draft angle or neutral plane missing') + self.lines.append(f' {var} = [scad.draft_rsolid(solid=_b, faces_to_draft={selector}, angle={fmt_num(angle)}, plane_origin={fmt_vec(plane.get("origin", (0, 0, 0)))}, plane_normal={fmt_vec(plane.get("normal", (0, 0, 1)))}) for _b in {inputs[0]}]') + elif op in {'offset', 'shell'}: + if len(inputs) != 1: + raise ValueError('offset requires one parent feature') + selections = step.get('selection', []) + selector = fingerprint_selector(selections, 'face') if selections else '[]' + self.uses_ql |= bool(selections) + amount = _named(p, 'offset', 'amount', 'thickness', 'distance') + if amount is None: + raise ValueError('offset distance missing') + self.lines.append(f' {var} = [scad.offset_rsolid(solid=_b, amount={fmt_num(amount)}, openings={selector}, tolerance={fmt_num(p.get("tolerance", 1e-4))}, kind={str(p.get("kind", "ARC"))!r}) for _b in {inputs[0]}]') + elif op == 'split': + self.split(step, p, inputs, var) + elif op in {'transform', 'translate', 'rotate', 'mirror', 'scale', 'move', 'moved', 'located', 'locate', 'transform_shape', 'transform_geometry'}: + self.transform(op, p, inputs, var) + else: + raise ValueError(f'unsupported op: {op}') + components = step.get('result_components', []) + if components and all(fp.get('bbox') is not None for fp in components): + # Kernel output order is not stable across environments. Restore the + # traced component order before indexed selections and modifications. + self.uses_ql = True + selectors = [fingerprint_selector([fp], 'solid') for fp in components] + self.lines.append(f' {var} = [{", ".join(f"{selector}.resolve({var})[0]" for selector in selectors)}]') + self.lines.append('') + self.variables[ident] = var + self.steps[ident] = step + self.feature_count += 1 + + def primitive(self, op, p, var): + plane = p.get('plane') or {} + origin = _named(p, 'origin', 'center', default=plane.get('origin', (0, 0, 0))) + axis = _named(p, 'axis', default=plane.get('normal', (0, 0, 1))) + if isinstance(axis, dict): + origin, axis = axis.get('origin', origin), axis.get('direction', (0, 0, 1)) + x_dir = plane.get('x_dir', (1, 0, 0)) + if op == 'box': + length = _named(p, 'length', 'x', default=p.get('width')) + width = _named(p, 'width', 'y', default=p.get('height')) + height = _named(p, 'height', 'z', default=p.get('depth')) + u, v = unit(x_dir), unit(cross(unit(axis), unit(x_dir))) + bottom = [float(origin[i]) + float(length) * u[i] / 2 + float(width) * v[i] / 2 for i in range(3)] + self.lines.extend([f' with scad.SimpleWorkplane(origin=(0, 0, 0), normal={fmt_vec(axis)}, x_dir={fmt_vec(x_dir)}):', + f' {var} = [scad.make_box_rsolid(width={fmt_num(length)}, height={fmt_num(width)}, depth={fmt_num(height)}, bottom_face_center={fmt_vec([dot(bottom, u), dot(bottom, v), dot(bottom, unit(axis))])})]']) + elif op in {'cylinder', 'cone'}: + angle = _named(p, 'angle', 'arc_size', default=360) + if abs(float(angle) - 360) > 1e-9: + axis, x_dir = unit(axis), unit(x_dir) + y_dir = unit(cross(axis, x_dir)) + def world(x, y, z): + return [origin[i] + x * x_dir[i] + y * y_dir[i] + z * axis[i] for i in range(3)] + if op == 'cylinder': + radius = float(p['radius']) + theta = math.radians(float(angle)) + start, mid, end = world(radius, 0, 0), world(radius * math.cos(theta / 2), radius * math.sin(theta / 2), 0), world(radius * math.cos(theta), radius * math.sin(theta), 0) + edges = [{'kind': 'line', 'start': origin, 'end': start}, {'kind': 'arc', 'start': start, 'mid': mid, 'end': end}, {'kind': 'line', 'start': end, 'end': origin}] + profile = {'origin': origin, 'u': x_dir, 'v': y_dir, 'normal': axis, 'wires': [{'edges': edges}]} + face = self.profile(profile, var + '_sector') + self.lines.append(f' {var} = [scad.extrude_rsolid(profile={face}, direction={fmt_vec(axis)}, distance={fmt_num(p["height"])})]') + else: + bottom_radius, top_radius = float(_named(p, 'base_radius', 'radius1', 'bottom_radius')), float(_named(p, 'radius2', 'top_radius', default=0)) + points = [world(0, 0, 0), world(bottom_radius, 0, 0), world(top_radius, 0, float(p['height'])), world(0, 0, float(p['height']))] + edges = [{'kind': 'line', 'start': a, 'end': b} for a, b in zip(points, points[1:] + points[:1]) if sum((x - y) ** 2 for x, y in zip(a, b)) > 1e-20] + profile = {'origin': origin, 'u': x_dir, 'v': axis, 'normal': cross(x_dir, axis), 'wires': [{'edges': edges}]} + face = self.profile(profile, var + '_meridian') + self.lines.append(f' {var} = [scad.revolve_rsolid(profile={face}, axis={fmt_vec(axis)}, angle={fmt_num(angle)}, origin={fmt_vec(origin)})]') + return + if op == 'cylinder': + args = f'radius={fmt_num(p["radius"])}' + else: + args = f'bottom_radius={fmt_num(_named(p, "radius1", "bottom_radius", "base_radius"))}, top_radius={fmt_num(_named(p, "radius2", "top_radius", default=0))}' + self.lines.append(f' {var} = [scad.make_{op}_rsolid({args}, height={fmt_num(p["height"])}, bottom_face_center={fmt_vec(origin)}, axis={fmt_vec(axis)})]') + elif op == 'sphere': + if any(abs(float(p.get(key, default)) - default) > 1e-9 for key, default in [('angle1', -90), ('angle2', 90), ('angle3', 360)]): + radius, axis, x_dir = float(p['radius']), unit(axis), unit(x_dir) + theta1, theta2 = math.radians(float(p.get('angle1', -90))), math.radians(float(p.get('angle2', 90))) + def meridian(theta): + return [origin[i] + radius * math.cos(theta) * x_dir[i] + radius * math.sin(theta) * axis[i] for i in range(3)] + start, mid, end = meridian(theta1), meridian((theta1 + theta2) / 2), meridian(theta2) + bottom_axis = [origin[i] + radius * math.sin(theta1) * axis[i] for i in range(3)] + top_axis = [origin[i] + radius * math.sin(theta2) * axis[i] for i in range(3)] + edges = [{'kind': 'arc', 'start': start, 'mid': mid, 'end': end}] + edges.extend({'kind': 'line', 'start': a, 'end': b} for a, b in [(end, top_axis), (top_axis, bottom_axis), (bottom_axis, start)] if sum((x - y) ** 2 for x, y in zip(a, b)) > 1e-20) + profile = {'origin': origin, 'u': x_dir, 'v': axis, 'normal': cross(x_dir, axis), 'wires': [{'edges': edges}]} + face = self.profile(profile, var + '_meridian') + self.lines.append(f' {var} = [scad.revolve_rsolid(profile={face}, axis={fmt_vec(axis)}, angle={fmt_num(p.get("angle3", 360))}, origin={fmt_vec(origin)})]') + return + self.lines.append(f' {var} = [scad.make_sphere_rsolid(radius={fmt_num(p["radius"])}, center={fmt_vec(origin)})]') + else: + start = _named(p, 'start_angle', 'angle1', default=0) + end = _named(p, 'end_angle', 'angle2', default=360) + if abs(float(start)) > 1e-9 or abs(float(end) - 360) > 1e-9: + raise ValueError('partial torus tube needs a traced meridian closure profile') + major, minor = _named(p, 'major_radius', 'radius1'), _named(p, 'minor_radius', 'radius2') + axis = unit(axis) + x_dir = unit(x_dir) + profile_origin = [o + float(major) * x for o, x in zip(origin, x_dir)] + profile = {'origin': profile_origin, 'u': x_dir, 'v': axis, 'normal': cross(x_dir, axis), + 'wires': [{'edges': [{'kind': 'circle', 'center': profile_origin, 'radius': minor}]}]} + face = self.profile(profile, var + '_meridian') + self.lines.append(f' {var} = [scad.revolve_rsolid(profile={face}, axis={fmt_vec(axis)}, angle={fmt_num(_named(p, "major_angle", "angle3", "angle", default=360))}, origin={fmt_vec(origin)})]') + + def transform(self, op, p, inputs, var): + if len(inputs) != 1: + raise ValueError('transform requires one parent feature') + expression = '_b' + matrix = _named(p, 'matrix', 'matrix4x4', 't_matrix', 'location', 'loc') + if matrix is None and isinstance(p.get('transform'), (dict, list, tuple)): + matrix = p['transform'] + if matrix is not None: + try: + scales, axis, angle, vector = _matrix_operations(matrix) + except ValueError as error: + if 'shear' not in str(error): + raise + raw_matrix = matrix.get('matrix') if isinstance(matrix, dict) else matrix + expression = f'scad.transform_rsolid(solid=_b, matrix={fmt_literal(raw_matrix)})' + self.lines.append(f' {var} = [{expression} for _b in {inputs[0]}]') + return + if any(abs(x - 1) > 1e-10 for x in scales): + expression = f'scad.scale_rsolid(solid={expression}, factors={fmt_vec(scales)}, center=(0, 0, 0))' + if abs(angle) > 1e-10: + expression = f'scad.rotate_shape(shape={expression}, angle={fmt_num(angle)}, axis={fmt_vec(axis)}, origin=(0, 0, 0))' + if any(abs(x) > 1e-10 for x in vector): + expression = f'scad.translate_shape(shape={expression}, vector={fmt_vec(vector)})' + elif op == 'mirror' or p.get('mirror_plane') is not None: + plane = p.get('mirror_plane') or p.get('plane') or {} + expression = f'scad.mirror_shape(shape=_b, plane_origin={fmt_vec(plane.get("origin", (0, 0, 0)))}, plane_normal={fmt_vec(plane.get("normal", (0, 0, 1)))})' + elif op == 'rotate' or p.get('angle') is not None: + axis, origin = _axis(p) + expression = f'scad.rotate_shape(shape=_b, angle={fmt_num(p["angle"])}, axis={fmt_vec(axis)}, origin={fmt_vec(origin)})' + elif op == 'scale' or p.get('method') == 'scale' or p.get('factor') is not None or p.get('factors') is not None: + factors = _named(p, 'factors', 'factor', 'scale', default=1) + if isinstance(factors, (int, float)): + factors = (factors,) * 3 + expression = f'scad.scale_rsolid(solid=_b, factors={fmt_vec(factors)}, center={fmt_vec(_named(p, "center", "about", default=(0, 0, 0)))})' + else: + vector = _named(p, 'vector', 'translation', 'offset') + if vector is None: + raise ValueError('transform has no supported parameters') + expression = f'scad.translate_shape(shape=_b, vector={fmt_vec(vector)})' + self.lines.append(f' {var} = [{expression} for _b in {inputs[0]}]') + + def split(self, step, p, inputs, var): + if len(inputs) != 1: + raise ValueError('split requires one parent feature') + plane = _named(p, 'plane', 'bisect_by', 'tool', default={}) + if not isinstance(plane, dict) or 'normal' not in plane: + raise ValueError('only planar solid splits are supported') + origin, u, v, normal = frame(plane) + source_step = self.steps[step['inputs'][0]] + bbox = source_step.get('result', {}).get('bbox') or self.trace.get('b3d_bbox') + if not bbox or len(bbox) != 6: + raise ValueError('split needs the source feature bounding box') + corners = [(x, y, z) for x in (bbox[0], bbox[3]) for y in (bbox[1], bbox[4]) for z in (bbox[2], bbox[5])] + projected = [[dot([c[i] - origin[i] for i in range(3)], axis) for c in corners] for axis in (u, v, normal)] + margin = max(math.sqrt(sum((bbox[i + 3] - bbox[i]) ** 2 for i in range(3))), 1) + center2 = [(min(a) + max(a)) / 2 for a in projected[:2]] + width, height = [max(a) - min(a) + margin * 2 for a in projected[:2]] + depth = max(abs(x) for x in projected[2]) + margin + tool_origin = [origin[i] + center2[0] * u[i] + center2[1] * v[i] for i in range(3)] + keep = str(p.get('keep', 'BOTH')).upper().split('.')[-1] + refs = [] + component_sides = step.get('result_component_sides') + ordered_sides = component_sides if keep == 'BOTH' and component_sides else ['TOP', 'BOTTOM'] + for side in ordered_sides: + label = str(side).lower() + if label not in {'top', 'bottom'}: + raise ValueError(f'unknown split component side: {side}') + sign = 1 if label == 'top' else -1 + if keep != 'BOTH' and keep != label.upper(): + continue + tool = var + '_' + label + self.lines.extend([f' with scad.SimpleWorkplane(origin={fmt_vec(tool_origin)}, normal={fmt_vec([sign * x for x in normal])}, x_dir={fmt_vec(u)}):', + f' {tool} = scad.make_box_rsolid(width={fmt_num(width)}, height={fmt_num(height)}, depth={fmt_num(depth)}, bottom_face_center=(0, 0, 0))']) + refs.append(f'scad.boolean_rsolidlist(left={inputs[0]}, right=[{tool}], operation="intersect")') + if not refs: + raise ValueError(f'unknown split keep mode: {keep}') + self.lines.append(f' {var} = [_piece for _group in [{", ".join(refs)}] for _piece in _group]') + + def replay(self): + for step in self.trace.get('steps', []): + before = len(self.lines) + before_ql = self.uses_ql + before_sketches = len(self.snapshots) + before_slugs = dict(self.slugs.counts) + try: + self.build_step(step) + for snapshot in self.snapshots[before_sketches:]: + snapshot.update({'feature_id': step.get('id'), 'op': step.get('op'), 'role': 'profile'}) + except (ValueError, KeyError, TypeError, IndexError) as error: + del self.lines[before:] + del self.snapshots[before_sketches:] + self.uses_ql = before_ql + self.slugs.counts = before_slugs + self.unsupported.append(f'{step.get("id", "?")} {step.get("op", "?")}: {error}') + requested = self.trace.get('result_refs') if 'result_refs' in self.trace else self.trace.get('results') + if requested is None: + requested = [self.trace['steps'][-1]['id']] if self.trace.get('steps') else [] + if isinstance(requested, str): + requested = [requested] + refs = [self.variables[x] for x in requested if isinstance(x, str) and x in self.variables] + missing = [x for x in requested if x not in self.variables] + if missing: + self.unsupported.append(f'final result features unavailable: {missing}') + if not refs: + self.unsupported.append('feature tree produced no solid') + if self.constraints_mode: + self.recover_constraints() + count = int(self.trace.get('solid_count') or sum(self.steps[x].get('result', {}).get('solid_count', 1) for x in requested if x in self.steps) or 1) + source = emit_module(self.stem, self.lines, refs, self.unsupported, self.uses_ql, count) + return source, {'status': 'partial' if self.unsupported else 'ok', 'feature_count': self.feature_count, + 'unsupported': self.unsupported, 'result_refs': requested, + 'notes': [], 'schema_version': '1.0', 'solid_count': count, + 'artifact_type': 'assembly' if count > 1 else 'part', + 'sketches': self.snapshots, 'sketch_count': len(self.snapshots), + 'constraint_recovery': self.constraint_reports} + + def recover_constraints(self): + """Reuse the source-agnostic CQ inference engine without changing it. + + It admits only geometry-entailed constraints whose production solver + preserves coordinates. Unsupported entity families retain geometry. + """ + import sys + from pathlib import Path + sibling = str(Path(__file__).resolve().parents[2] / 'cadqueryftc') + if sibling not in sys.path: + sys.path.insert(0, sibling) + from cqftc.constraints import emit_constraint_lines, recover_constraints_guarded + for snapshot in self.snapshots: + if snapshot.get('compact'): + self.constraint_reports.append({'name': snapshot['name'], 'status': 'unsupported', + 'reason': 'constraint emission is unavailable for compact multi-loop sketches', 'constraints': []}) + continue + if any(entity['kind'] not in {'point', 'line', 'circle', 'arc'} for entity in snapshot['entities']): + self.constraint_reports.append({'name': snapshot['name'], 'status': 'unsupported', + 'reason': 'constraint recovery does not handle ellipse/B-spline entities', 'constraints': []}) + continue + try: + report = recover_constraints_guarded(snapshot, timeout=30) + except Exception as error: + report = {'status': 'error', 'reason': str(error), 'constraints': []} + report['name'] = snapshot['name'] + self.constraint_reports.append(report) + if not report.get('coords_ok'): + continue + name = snapshot['name'] + constraints = [line.replace(' s = ', f' {name} = ').replace('sketch=s,', f'sketch={name},') + for line in emit_constraint_lines(report)] + for index, line in enumerate(self.lines): + if f'sketch={name}, profile=' in line and ('make_wire_from_sketch_rwire' in line or 'make_face_from_sketch_rface' in line): + self.lines[index:index] = constraints + break + + +def replay_trace_to_ftc(trace: Any, *, stem: str = 'part', constraints_mode: bool = False): + if hasattr(trace, 'to_dict'): + trace = trace.to_dict() + if not isinstance(trace, Mapping): + raise TypeError('trace must be a portable JSON mapping') + return TraceReplayer(trace, stem, constraints_mode=constraints_mode).replay() diff --git a/tools/research/build123dftc/b3ftc/schema.py b/tools/research/build123dftc/b3ftc/schema.py new file mode 100644 index 00000000..58a7f0c9 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/schema.py @@ -0,0 +1,8 @@ +"""Versioned, portable feature trace contract.""" +SCHEMA_VERSION = "1.0" + + +def empty_trace(): + return {"schema_version": SCHEMA_VERSION, "steps": [], "result_refs": [], + "b3d_status": "ok", "b3d_volume": None, "b3d_bbox": None, + "solid_count": 0, "unsupported": [], "error": ""} diff --git a/tools/research/build123dftc/b3ftc/tracer.py b/tools/research/build123dftc/b3ftc/tracer.py new file mode 100644 index 00000000..fc3a43c5 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/tracer.py @@ -0,0 +1,471 @@ +"""Execute build123d and capture the actual solid construction graph. + +Instrumentation sits at the topology API: Builder, algebra and direct topology +calls consequently share one history. Sketches are transcribed as analytic/NURBS +profiles at feature boundaries. Tracing executes Python; only trusted models +should be supplied. Patches are scoped and restored even on execution failure. +""" +from __future__ import annotations + +from contextlib import contextmanager +import functools +import hashlib +import inspect +from pathlib import Path +import sys +import threading +import traceback +from typing import Any + +from . import geometry +from .schema import SCHEMA_VERSION, empty_trace + +schema_version = SCHEMA_VERSION +_LOCK = threading.RLock() + + +class Recorder: + def __init__(self): + self.trace = empty_trace() + self.depth = 0 + self.refs: dict[int, str] = {} + self.components: dict[int, tuple[str, int, Any]] = {} + self.ref_solids: dict[str, list[Any]] = {} + self.patches: list[tuple[Any, str, Any, bool]] = [] + self.retained: list[Any] = [] + self.serial = 0 + + @staticmethod + def key(shape): + return hash(shape.wrapped) + + @staticmethod + def is_solid(shape): + return hasattr(shape, "solids") and bool(shape.solids()) + + def register(self, shape, ref): + if shape is None: + return + if isinstance(shape, (list, tuple)): + solids = [s for item in shape if item is not None for s in item.solids()] + if len(solids) == 1: + self.register(solids[0], ref) + else: + for index, solid in enumerate(solids): + self.components[self.key(solid)] = (ref, index, solid) + self.retained.append(solid.wrapped) + for item in shape: + if item is not None and len(item.solids()) == 1: + single = item.solids()[0] + if self.key(single) in self.components: + self.components[self.key(item)] = self.components[self.key(single)] + return + if not hasattr(shape, "wrapped") or shape.wrapped is None: + return + self.refs[self.key(shape)] = ref + self.retained.append(shape.wrapped) + solids = shape.solids() + if len(solids) == 1: + self.refs[self.key(solids[0])] = ref + self.retained.append(solids[0].wrapped) + elif len(solids) > 1: + for index, solid in enumerate(solids): + self.components[self.key(solid)] = (ref, index, solid) + self.retained.append(solid.wrapped) + + def emit(self, op, inputs, parameters, result, source, **extra): + import build123d as b + from OCP.TopLoc import TopLoc_Location + results = result if isinstance(result, (list, tuple)) else [result] + solids = [s for obj in results if obj is not None for s in obj.solids()] + if len(solids) > 1: + extra["result_components"] = [geometry.metrics(s) for s in solids] + if op == "union" and len(solids) > 1: + groups = [] + self.depth += 1 + try: + for output in solids: + group = [] + output_box = geometry.metrics(output)["bbox"] + for input_ref in inputs: + for operand in self.ref_solids.get(input_ref, []): + box = geometry.metrics(operand)["bbox"] + if any(box[i] < output_box[i] - 1e-5 or box[i+3] > output_box[i+3] + 1e-5 for i in range(3)): + continue + common = operand.intersect(output) + overlap = geometry.metrics(common)["volume"] if common is not None else 0. + operand_volume = geometry.metrics(operand)["volume"] + if abs(overlap - operand_volume) <= max(1e-6, abs(operand_volume) * 1e-7): + group.extend(self.reference(operand)) + groups.append(list(dict.fromkeys(group))) + finally: + self.depth -= 1 + extra["result_groups"] = groups + self.serial += 1 + ref = f"s{self.serial}" + step = {"id": ref, "op": op, "inputs": list(dict.fromkeys(inputs)), + "parameters": parameters, "source": source, + "result": geometry.metrics(result), **extra} + self.trace["steps"].append(step) + self.register(result, ref) + self.ref_solids[ref] = [b.Solid(s.wrapped.Moved(TopLoc_Location())) for s in solids] + return ref + + def unsupported(self, message, shape=None, source="unknown"): + entry = {"source": source, "reason": message} + if entry not in self.trace["unsupported"]: + self.trace["unsupported"].append(entry) + if shape is not None: + return self.emit("unsupported", [], {"reason": message}, shape, source) + return None + + def reference(self, shape): + if shape is None: + return [] + if isinstance(shape, (list, tuple)): + return [r for item in shape for r in self.reference(item)] + if hasattr(shape, "part") and not hasattr(shape, "wrapped"): + return self.reference(shape.part) + if not hasattr(shape, "wrapped") or shape.wrapped is None or not self.is_solid(shape): + return [] + key = self.key(shape) + if key in self.refs: + return [self.refs[key]] + if key in self.components: + parent, index, solid = self.components[key] + return [self.emit("component", [parent], {"index": index, "fingerprint": geometry.metrics(solid)}, solid, "Shape.solids")] + solids = shape.solids() + known = [self.refs.get(self.key(s)) for s in solids] + if all(known): + if len(set(known)) == 1: + self.register(shape, known[0]) + return [known[0]] + return [self.emit("compound", known, {}, shape, "Compound")] + if all(self.key(s) in self.refs or self.key(s) in self.components for s in solids): + children = [ref for solid in solids for ref in self.reference(solid)] + return [self.emit("compound", children, {}, shape, "Compound")] + ref = self.unsupported(f"Untraced solid construction: {type(shape).__name__}", shape) + return [ref] + + def patch(self, owner, name, replacement): + own_attribute = name in owner.__dict__ + original = inspect.getattr_static(owner, name) + self.patches.append((owner, name, original, own_attribute)) + setattr(owner, name, replacement) + + def bind(self, fn, args, kwargs): + bound = inspect.signature(fn).bind(*args, **kwargs) + bound.apply_defaults() + return dict(bound.arguments) + + def wrap(self, owner, name, op, *, factory=False): + fn = getattr(owner, name) + descriptor = inspect.getattr_static(owner, name) + + @functools.wraps(fn) + def wrapped(*args, **kwargs): + if self.depth: + return fn(*args, **kwargs) + receiver = None if factory else args[0] + if receiver is not None and not self.is_solid(receiver): + return fn(*args, **kwargs) + params = self.bind(fn, args, kwargs) + params.pop("self", None) + # Materialize iterables once: feature generators must still execute normally. + for field in ("objs", "profiles", "edge_list", "faces", "openings", "inner_wires"): + value = params.get(field) + if value is not None and not isinstance(value, (list, tuple)) and not hasattr(value, "wrapped"): + params[field] = list(value) + # Rebind the materialized values to preserve the original call contract. + bound = inspect.signature(fn).bind(*args, **kwargs) + for field, value in params.items(): + if field in bound.arguments: + bound.arguments[field] = value + inputs = self.reference(receiver) if receiver is not None else [] + extra = {} + encoded = {} + try: + for field, value in params.items(): + if field in {"obj", "profile", "section", "surface"} and op in {"extrude", "extrude_taper", "extrude_until", "revolve", "sweep", "extrude_twist", "thicken"}: + extra["profile"] = geometry.profile(value) + elif field in {"objs", "profiles"} and op in {"loft", "sweep_multi"}: + extra["profiles"] = [geometry.profile(v) for v in value] + elif field == "path" and op in {"sweep", "sweep_multi"}: + extra["path"] = geometry.path(value) + elif field in {"edge_list", "faces", "openings"}: + extra["selection"] = [geometry.fingerprint(v, receiver) for v in value or []] + if receiver is not None and len(receiver.solids()) > 1: + kind = "edge" if field == "edge_list" else "face" + extra["component_selections"] = [ + [geometry.fingerprint(v, solid) for v in value or [] + if any(child.wrapped.IsSame(v.wrapped) for child in + (solid.edges() if kind == "edge" else solid.faces()))] + for solid in receiver.solids()] + elif field in {"to_fuse", "to_cut", "to_intersect", "target"}: + inputs.extend(self.reference(value)) + elif field == "inner_wires": + # build123d uses explicit holes only for Wire sections. + # A Face already owns the loops actually consumed by the feature. + import build123d as b + section = params.get("section") + extra["inner_wires"] = ([] if isinstance(section, b.Face) else + [geometry.wire(v) for v in value or []]) + else: + encoded[field] = geometry.serialize(value) + except Exception as exc: + extra["geometry_error"] = str(exc) + self.unsupported(f"Cannot transcribe {name} inputs: {exc}", source=f"{owner.__name__}.{name}") + if op == "chamfer" and params.get("length2") is not None and params["length2"] != params["length"]: + # The native kernel assigns distance1 relative to an adjacent + # face, even when no reference face is supplied by the caller. + import build123d as b + from build123d.topology.three_d import IndexedDataMap_TopoDS_Shape_List_TopoDS_Shape_TopTools_ShapeMapHasher + from OCP.TopExp import TopExp + from OCP.TopAbs import TopAbs_EDGE, TopAbs_FACE + adjacency = IndexedDataMap_TopoDS_Shape_List_TopoDS_Shape_TopTools_ShapeMapHasher() + TopExp.MapShapesAndAncestors_s(receiver.wrapped, TopAbs_EDGE, TopAbs_FACE, adjacency) + directions = [] + for selected in params["edge_list"]: + explicit = params.get("face") + reference = explicit if explicit is not None else next(face for face in receiver.faces() if face.wrapped.IsSame(adjacency.FindFromKey(selected.wrapped).First())) + direction = geometry.vector(reference.normal_at(selected.position_at(.5))) + directions.append(direction) + encoded["reference_directions"] = directions + if directions and all(sum((a-b)**2 for a,b in zip(directions[0], item)) < 1e-12 for item in directions): + encoded["reference_direction"] = directions[0] + if op == "transform": + encoded["method"] = name + if name == "scale" and params.get("about") is None: + encoded["about"] = geometry.vector(receiver.location.position) + if name == "transformed": + from OCP.gp import gp_Trsf, gp_Ax1, gp_Pnt, gp_Dir, gp_Vec + import math + rotation = params["rotate"] + if hasattr(rotation, "X"): + rotation = geometry.vector(rotation) + rotations = [] + for i, angle in enumerate(rotation): + trsf = gp_Trsf() + axis = [0., 0., 0.] + axis[i] = 1. + trsf.SetRotation(gp_Ax1(gp_Pnt(), gp_Dir(*axis)), math.radians(angle)) + rotations.append(trsf) + translation = gp_Trsf() + offset = params["offset"] + translation.SetTranslation(gp_Vec(*(geometry.vector(offset) if hasattr(offset, "X") else offset))) + transformation = translation * rotations[0] * rotations[1] * rotations[2] + encoded["matrix"] = [[float(transformation.Value(i, j)) for j in range(1, 5)] for i in range(1, 4)] + [[0., 0., 0., 1.]] + if name in {"locate", "located"}: + # Absolute location requires replacing the current shape location. + import build123d as b + loc = params["loc"] + encoded["matrix"] = geometry.location_matrix(loc * receiver.location.inverse()) + elif name in {"move", "moved"}: + loc = params["loc"] + encoded["matrix"] = geometry.location_matrix(getattr(loc, "location", loc)) + self.depth += 1 + try: + result = fn(*bound.args, **bound.kwargs) + finally: + self.depth -= 1 + if result is not None and (self.is_solid(result) if not isinstance(result, (list, tuple)) else any(self.is_solid(v) for v in result if v is not None)): + if op == "split" and isinstance(result, tuple) and len(result) == 2: + for value, keep in zip(result, ["TOP", "BOTTOM"]): + if value is not None: + self.emit(op, inputs, {**encoded, "keep": keep}, value, f"{owner.__name__}.{name}", **extra) + else: + self.emit(op, inputs, encoded, result, f"{owner.__name__}.{name}", **extra) + return result + + if isinstance(descriptor, classmethod): + # `fn` is already bound to the class; discard the newly supplied cls. + @functools.wraps(fn) + def class_wrapped(cls, *args, **kwargs): + return wrapped(*args, **kwargs) + self.patch(owner, name, classmethod(class_wrapped)) + elif isinstance(descriptor, staticmethod): + self.patch(owner, name, staticmethod(wrapped)) + else: + self.patch(owner, name, wrapped) + + def install(self): + import build123d as b + # Compound algebra and Builder insertion can call the kernel boolean + # boundary directly, without Shape.fuse/cut/intersect. + original_boolean = b.Shape._bool_op + + @functools.wraps(original_boolean) + def boolean(shape, args, tools, operation): + if self.depth: + return original_boolean(shape, args, tools, operation) + args, tools = list(args), list(tools) + from OCP.BRepAlgoAPI import BRepAlgoAPI_Fuse, BRepAlgoAPI_Cut, BRepAlgoAPI_Common + op = next((name for cls, name in ((BRepAlgoAPI_Fuse, "union"), + (BRepAlgoAPI_Cut, "cut"), (BRepAlgoAPI_Common, "intersect")) + if isinstance(operation, cls)), None) + if op is None or not args or any(not self.is_solid(s) for s in [*args, *tools]): + return original_boolean(shape, args, tools, operation) + # Each side is a set of bodies, not a chain of intersections. + inputs = self.reference(b.Compound(args)) + if tools: + inputs.extend(self.reference(b.Compound(tools))) + self.depth += 1 + try: + result = original_boolean(shape, args, tools, operation) + finally: + self.depth -= 1 + if result is not None and self.is_solid(result): + self.emit(op, inputs, {}, result, "Shape._bool_op") + return result + + self.patch(b.Shape, "_bool_op", boolean) + original_solid_init = b.Solid.__init__ + + @functools.wraps(original_solid_init) + def solid_init(solid, obj=None, *args, **kwargs): + if self.depth or not isinstance(obj, b.Shell): + return original_solid_init(solid, obj, *args, **kwargs) + extra = {} + try: + extra["profiles"] = [geometry.profile(face) for face in obj.faces()] + except Exception as exc: + extra["geometry_error"] = str(exc) + self.unsupported(f"Cannot transcribe Solid(Shell) inputs: {exc}", source="Solid.__init__") + self.depth += 1 + try: + original_solid_init(solid, obj, *args, **kwargs) + finally: + self.depth -= 1 + if self.is_solid(solid): + self.emit("sew_solid", [], {}, solid, "Solid.__init__", **extra) + + self.patch(b.Solid, "__init__", solid_init) + factories = {"make_box": "box", "make_cylinder": "cylinder", "make_cone": "cone", + "make_sphere": "sphere", "make_torus": "torus", "make_wedge": "wedge", + "extrude": "extrude", "extrude_taper": "extrude_taper", "extrude_until": "extrude_until", + "extrude_linear_with_rotation": "extrude_twist", "revolve": "revolve", + "make_loft": "loft", "sweep": "sweep", "sweep_multi": "sweep_multi", "thicken": "thicken"} + for name, op in factories.items(): + if hasattr(b.Solid, name): + self.wrap(b.Solid, name, op, factory=True) + for name, op in {"fuse": "union", "cut": "cut", "intersect": "intersect", "split": "split"}.items(): + self.wrap(b.Shape, name, op) + for name, op in {"fillet": "fillet", "chamfer": "chamfer", "offset_3d": "offset", "hollow": "shell", "draft": "draft"}.items(): + owner = next((c for c in b.Solid.__mro__ if name in c.__dict__), None) + if owner is not None: + self.wrap(owner, name, op) + for name in ("moved", "move", "located", "locate", "translate", "rotate", "mirror", "scale", "transformed", "transform_shape", "transform_geometry"): + self.wrap(b.Shape, name, "transform") + original_clean = b.Shape.clean + original_copy = b.Shape.__deepcopy__ + + @functools.wraps(original_copy) + def deepcopy(shape, memo): + refs = self.reference(shape) if not self.depth and self.is_solid(shape) else [] + self.depth += 1 + try: + result = original_copy(shape, memo) + finally: + self.depth -= 1 + if refs: + self.register(result, refs[0]) + return result + self.patch(b.Shape, "__deepcopy__", deepcopy) + original_location = inspect.getattr_static(b.Shape, "location") + + def set_location(shape, loc): + if self.depth or not self.is_solid(shape): + original_location.fset(shape, loc) + return + inputs = self.reference(shape) + matrix = geometry.location_matrix(loc * shape.location.inverse()) + self.depth += 1 + try: + original_location.fset(shape, loc) + finally: + self.depth -= 1 + self.emit("transform", inputs, {"method": "locate", "matrix": matrix}, shape, "Shape.location") + self.patch(b.Shape, "location", property(original_location.fget, set_location, original_location.fdel, original_location.__doc__)) + + @functools.wraps(original_clean) + def clean(shape): + refs = self.reference(shape) if not self.depth and self.is_solid(shape) else [] + self.depth += 1 + try: + result = original_clean(shape) + finally: + self.depth -= 1 + if refs: + self.register(result, refs[0]) + return result + self.patch(b.Shape, "clean", clean) + + def restore(self): + for owner, name, original, own_attribute in reversed(self.patches): + if own_attribute: + setattr(owner, name, original) + else: + delattr(owner, name) + self.patches.clear() + + +def _find_result(namespace): + from build123d import BuildPart, Shape + for name in ("result", "part", "model", "solid", "body"): + if name not in namespace: + continue + value = namespace[name] + if isinstance(value, BuildPart): + return value.part + # An explicit output is authoritative, including an empty or invalid one. + return value + for value in reversed(list(namespace.values())): + if isinstance(value, BuildPart) and value.part is not None: + return value.part + if isinstance(value, Shape) and value.solids(): + return value + return None + + +def trace_source(source: str, filename: str = "") -> dict[str, Any]: + """Execute a trusted program and return a portable feature graph.""" + with _LOCK: + recorder = Recorder() + namespace = {"__name__": "__build123d_trace__", "__file__": filename} + old_path = list(sys.path) + sys.path.insert(0, str(Path(filename).resolve().parent)) + try: + recorder.install() + try: + exec(compile(source, filename, "exec"), namespace) + except Exception: + recorder.trace["b3d_status"] = "error" + recorder.trace["error"] = traceback.format_exc() + result = _find_result(namespace) + values = result if isinstance(result, (list, tuple)) else [result] + from build123d import Shape + if (not values or any(v is not None and not isinstance(v, Shape) for v in values) + or not any(v is not None and recorder.is_solid(v) for v in values)): + recorder.trace["b3d_status"] = "error" + recorder.trace["error"] += "\nNo solid result found in model namespace" + else: + recorder.trace["result_refs"] = recorder.reference(result) + summary = geometry.metrics(result) + recorder.trace.update(b3d_volume=summary["volume"], b3d_bbox=summary["bbox"], solid_count=summary["solid_count"]) + recorder.trace["b3d_default_volume"] = summary.get("default_volume", summary["volume"]) + recorder.trace["b3d_volume_gk"] = summary["volume"] + recorder.trace["b3d_valid"] = all(v.is_valid for v in values if v is not None) + recorder.trace["b3d_area"] = summary["area"] + finally: + recorder.restore() + sys.path[:] = old_path + recorder.trace["source_file"] = filename + recorder.trace["source_sha256"] = hashlib.sha256(source.encode("utf-8")).hexdigest() + import build123d + recorder.trace["build123d_version"] = getattr(build123d, "__version__", "unknown") + return recorder.trace + + +def trace_file(path: str | Path) -> dict[str, Any]: + path = Path(path).resolve() + return trace_source(path.read_text(encoding="utf-8"), str(path)) diff --git a/tools/research/build123dftc/b3ftc/validation.py b/tools/research/build123dftc/b3ftc/validation.py new file mode 100644 index 00000000..32720242 --- /dev/null +++ b/tools/research/build123dftc/b3ftc/validation.py @@ -0,0 +1,314 @@ +"""Stage 3 acceptance, independent of the source CAD interpreter. + +Each generated program runs in a separate process. Acceptance requires all +source metrics, complete translation, real nonempty valid solids, and matching +volume, absolute bounds and solid count. Optional STEP comparison checks both +directions of the geometric difference. +""" +from __future__ import annotations + +import json +import math +import os +from pathlib import Path +import signal +import subprocess +import sys +import tempfile +import time +from typing import Any, Mapping + +VOLUME_RTOL = 1e-3 +VOLUME_ATOL = 1e-6 +BBOX_RTOL = 1e-3 +BBOX_ATOL = 1e-4 +DIFFERENCE_RTOL = 1e-3 + + +def _finite_number(value: Any) -> bool: + return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) + + +def _bbox(value: Any) -> bool: + return (isinstance(value, (list, tuple)) and len(value) == 6 + and all(_finite_number(v) for v in value) + and all(value[i] <= value[i + 3] for i in range(3))) + + +def _positive_count(value: Any) -> bool: + return isinstance(value, int) and not isinstance(value, bool) and value > 0 + + +def _translation_notes(payload: Mapping[str, Any]) -> bool: + return any(bool(value) for name, value in payload.items() + if name in {"unsupported", "untranslated", "unhandled"} or name.startswith("unknown")) + + +def compare_metrics(trace: Mapping[str, Any], actual: Mapping[str, Any], + meta: Mapping[str, Any] | None, *, + volume_rtol: float = VOLUME_RTOL, volume_atol: float = VOLUME_ATOL, + bbox_rtol: float = BBOX_RTOL, bbox_atol: float = BBOX_ATOL, + difference_rtol: float = DIFFERENCE_RTOL, + require_reference: bool = False) -> dict[str, Any]: + """Compare untrusted JSON evidence; missing metrics always reject.""" + reasons: list[str] = [] + if trace.get("b3d_status") != "ok": + reasons.append("source_failed") + expected_volume, expected_bbox = trace.get("b3d_volume"), trace.get("b3d_bbox") + expected_count = trace.get("solid_count") + valid_source = (_finite_number(expected_volume) and expected_volume > 0 + and _bbox(expected_bbox) and _positive_count(expected_count) + and bool(trace.get("result_refs"))) + if not valid_source: + reasons.append("missing_source_metrics") + if trace.get("b3d_valid") is False or trace.get("b3d_is_valid") is False: + reasons.append("invalid_source") + if _translation_notes(trace): + reasons.append("unsupported_source") + if not isinstance(meta, Mapping) or meta.get("status") != "ok": + reasons.append("incomplete_translation") + if isinstance(meta, Mapping) and _translation_notes(meta): + reasons.append("untranslated_operations") + if actual.get("status") != "ok": + reasons.append("build_failed") + if not _positive_count(actual.get("body_count")): + reasons.append("empty_bodies") + if actual.get("is_valid") is not True: + reasons.append("invalid_topology") + volume, bounds, count = actual.get("volume"), actual.get("bbox"), actual.get("solid_count") + valid_actual = (_finite_number(volume) and volume > 0 and _bbox(bounds) + and _positive_count(count)) + if not valid_actual: + reasons.append("missing_actual_metrics") + volume_error = bbox_error = bbox_absolute_error = area_error = None + if valid_source and valid_actual: + volume_error = abs(volume - expected_volume) / abs(expected_volume) + if abs(volume - expected_volume) > volume_atol + volume_rtol * abs(expected_volume): + reasons.append("volume_mismatch") + # Six world coordinates, scaled by axis span (never by world position). + # A rigid translation therefore fails even when every extent matches. + spans = [max(expected_bbox[i + 3] - expected_bbox[i], 1.0) for i in range(3)] + deviations = [abs(a - b) for a, b in zip(bounds, expected_bbox)] + bbox_absolute_error = max(deviations) + bbox_error = max(delta / spans[i % 3] for i, delta in enumerate(deviations)) + if any(delta > bbox_atol + bbox_rtol * spans[i % 3] + for i, delta in enumerate(deviations)): + reasons.append("bbox_mismatch") + if count != expected_count: + reasons.append("solid_count_mismatch") + expected_area, area = trace.get("b3d_area"), actual.get("area") + if expected_area is not None: + if not (_finite_number(expected_area) and expected_area > 0 and _finite_number(area) and area > 0): + reasons.append("missing_area_metrics") + else: + area_error = abs(area - expected_area) / expected_area + if abs(area - expected_area) > volume_atol + volume_rtol * abs(expected_area): + reasons.append("area_mismatch") + difference = actual.get("symmetric_difference_volume") + difference_error = None + if require_reference: + reference_volume = actual.get("reference_volume") + if (actual.get("reference_status") != "ok" or not _finite_number(difference) + or difference < 0 or not _finite_number(reference_volume) or reference_volume <= 0): + reasons.append("reference_error") + else: + difference_error = difference / reference_volume + if difference > volume_atol + difference_rtol * reference_volume: + reasons.append("symmetric_difference_mismatch") + if "roundtrip_actual_volume" in actual: + exported = {"status": "ok", "volume": actual.get("roundtrip_actual_volume"), + "bbox": actual.get("roundtrip_actual_bbox"), + "solid_count": actual.get("roundtrip_actual_solid_count"), + "body_count": actual.get("body_count"), + "is_valid": actual.get("roundtrip_actual_valid")} + original = {"b3d_status": "ok", "b3d_volume": volume, "b3d_bbox": bounds, + "solid_count": count, "result_refs": ["actual"]} + check = compare_metrics(original, exported, {"status": "ok"}, + volume_rtol=volume_rtol, volume_atol=volume_atol, + bbox_rtol=bbox_rtol, bbox_atol=bbox_atol) + if check["quality"] != "accepted": + reasons.append("reference_roundtrip_changed_geometry") + return { + "quality": "rejected" if reasons else "accepted", "reasons": reasons, + "b3d_volume": expected_volume if _finite_number(expected_volume) else None, + "ftc_volume": volume if _finite_number(volume) else None, + "b3d_bbox": expected_bbox if _bbox(expected_bbox) else None, + "ftc_bbox": bounds if _bbox(bounds) else None, + "b3d_solid_count": expected_count, "ftc_solid_count": count, + "body_count": actual.get("body_count"), "is_valid": actual.get("is_valid"), + "volume_error": volume_error, "bbox_error": bbox_error, + "b3d_area": expected_area if _finite_number(expected_area) else None, + "ftc_area": area if _finite_number(area) else None, + "area_error": area_error, + "bbox_absolute_error": bbox_absolute_error, + "symmetric_difference_volume": difference if _finite_number(difference) else None, + "symmetric_difference_error": difference_error, + } + + +def _load_json(path: Path) -> dict[str, Any]: + payload = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(payload, dict): + raise ValueError(f"JSON root must be an object: {path}") + return payload + + +def _interpreter(executable: str | None) -> str: + executable = executable or sys.executable + # Keep a venv symlink instead of resolving it to the base Python binary. + return os.path.abspath(executable) if os.sep in executable else executable + + +def _process(command: list[str], staging: Path, env: Mapping[str, str], + output: Path, timeout: float) -> dict[str, Any]: + if timeout <= 0: + return {"status": "timeout", "error": "case timeout exhausted before reference comparison"} + process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, cwd=staging, env=env, + start_new_session=os.name == "posix") + try: + stdout, stderr = process.communicate(timeout=timeout) + except subprocess.TimeoutExpired: + if os.name == "posix": + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + else: + process.kill() + stdout, stderr = process.communicate() + return {"status": "timeout", "error": f"build exceeded {timeout:g} seconds", + "stdout": stdout[-4000:], "stderr": stderr[-4000:]} + if output.exists(): + try: + result = _load_json(output) + except (ValueError, OSError) as exc: + result = {"status": "worker_error", "error": str(exc)} + else: + result = {"status": "worker_error", "error": f"worker exited {process.returncode} without metrics"} + if process.returncode and result.get("status") == "ok": + result.update(status="worker_error", error=f"worker exited {process.returncode}") + if stdout.strip(): + result["stdout"] = stdout[-4000:] + if stderr.strip(): + result["stderr"] = stderr[-4000:] + return result + + +def _worker(ftc_path: Path, workdir: Path | None, timeout: float, + reference_step: Path | None, python_executable: str | None, + reference_python: str | None = None, + export_options: Mapping[str, Any] | None = None) -> dict[str, Any]: + if timeout <= 0 or not math.isfinite(timeout): + raise ValueError("timeout must be a positive finite number") + if workdir is not None: + workdir.mkdir(parents=True, exist_ok=True) + tool_dir = Path(__file__).resolve().parent.parent + repo_root = tool_dir.parents[2] + with tempfile.TemporaryDirectory(prefix="b3ftc-validate-", dir=workdir) as tmp: + staging = Path(tmp).resolve() + output = staging / "result.json" + command = [_interpreter(python_executable), str(tool_dir / "b3ftc/_validate_worker.py"), + "--ftc", str(ftc_path.resolve()), "--output", str(output), + "--staging-dir", str(staging)] + actual_step = staging / "actual.step" + if reference_step is not None and reference_python is not None: + command.extend(["--export-step", str(actual_step)]) + if export_options: + command.extend(["--export-options", json.dumps(export_options)]) + elif reference_step is not None: + command.extend(["--reference-step", str(reference_step.resolve())]) + env = os.environ.copy() + env["PYTHONPATH"] = os.pathsep.join([str(repo_root / "src"), str(tool_dir), + env.get("PYTHONPATH", "")]) + started = time.monotonic() + result = _process(command, staging, env, output, timeout) + if reference_python is not None and reference_step is not None and result.get("status") == "ok": + ref_output = staging / "reference.json" + command = [_interpreter(reference_python), str(tool_dir / "b3ftc/_reference_worker.py"), + "--actual-step", str(actual_step), "--reference-step", str(reference_step.resolve()), + "--output", str(ref_output)] + ref = _process(command, staging, env, ref_output, timeout - (time.monotonic() - started)) + result.update({key: value for key, value in ref.items() + if key.startswith(("reference_", "roundtrip_actual_", "symmetric_difference_"))}) + if ref.get("status") != "ok": + result.update(reference_status="error", reference_error=ref.get("reference_error", ref.get("error", ""))) + return result + + +def validate_row(ftc_path: Path, trace_path: Path, workdir: Path | None = None, *, + timeout: float = 120, reference_step: Path | None = None, + python_executable: str | None = None, + reference_python: str | None = None) -> dict[str, Any]: + """Validate one FTC. Errors are returned as rejected rows for batch use.""" + ftc_path, trace_path = Path(ftc_path), Path(trace_path) + stem = ftc_path.name.removesuffix(".ftc.py") + row: dict[str, Any] = {"stem": stem, "quality": "rejected", "metrics_quality": "rejected", "metrics_reasons": ["not_evaluated"]} + try: + if not ftc_path.is_file(): + return {**row, "build": "missing_ftc", "reasons": ["missing_ftc"]} + if not trace_path.is_file(): + return {**row, "build": "missing_trace", "reasons": ["missing_trace"]} + trace = _load_json(trace_path) + meta_path = ftc_path.with_name(stem + ".meta.json") + meta = _load_json(meta_path) if meta_path.is_file() else None + # Reject absent/failed source or incomplete conversion without executing it. + preliminary = compare_metrics(trace, {}, meta) + source_reasons = [reason for reason in preliminary["reasons"] if reason in { + "source_failed", "missing_source_metrics", "invalid_source", "unsupported_source", + "incomplete_translation", "untranslated_operations"}] + if source_reasons: + return {**row, **preliminary, "build": "not_run", "reasons": source_reasons, + "error": trace.get("error", "")} + metadata = trace.get("source_metadata") or {} + export_options = metadata.get("export_options", trace.get("export_options")) + metrics = _worker(ftc_path, Path(workdir) if workdir is not None else None, + timeout, Path(reference_step) if reference_step is not None else None, + python_executable, reference_python, export_options) + result = compare_metrics(trace, metrics, meta, require_reference=reference_step is not None) + basic = compare_metrics(trace, metrics, meta, require_reference=False) + return {**row, **result, "build": metrics.get("status", "worker_error"), + "metrics_quality": basic["quality"], "metrics_reasons": basic["reasons"], + "error": metrics.get("error", ""), + "reference_status": metrics.get("reference_status"), + "reference_kernel": metrics.get("reference_kernel"), + "reference_export_options": metrics.get("reference_export_options"), + "reference_boolean_fuzzy_tolerance": metrics.get("reference_boolean_fuzzy_tolerance"), + "reference_python": reference_python, + "build_kernel": metrics.get("build_kernel"), + "volume_method": metrics.get("volume_method"), + "area_method": metrics.get("area_method"), + "reference_error": metrics.get("reference_error", ""), + "stdout": metrics.get("stdout", ""), "stderr": metrics.get("stderr", "")} + except Exception as exc: + return {**row, "build": "validator_error", "reasons": ["validator_error"], + "error": f"{type(exc).__name__}: {exc}"} + + +def validate_directory(ftc_dir: Path, traces_dir: Path, *, timeout: float = 120, + reference_step_dir: Path | None = None, limit: int | None = None, + python_executable: str | None = None, + reference_python: str | None = None) -> dict[str, Any]: + """Check the union of FTC and trace stems, never omit a failed conversion.""" + ftc_dir, traces_dir = Path(ftc_dir), Path(traces_dir) + stems = sorted({path.name.removesuffix(".ftc.py") for path in ftc_dir.glob("*.ftc.py")} + | {path.name.removesuffix(".trace.json") for path in traces_dir.glob("*.trace.json")}) + if limit is not None: + if limit < 0: + raise ValueError("limit must be nonnegative") + stems = stems[:limit] + rows = [validate_row(ftc_dir / (stem + ".ftc.py"), traces_dir / (stem + ".trace.json"), + timeout=timeout, python_executable=python_executable, + reference_python=reference_python, + reference_step=(Path(reference_step_dir) / (stem + ".step")) + if reference_step_dir is not None else None) for stem in stems] + return {"schema_version": "1.0", "rows": rows, + "counts": {quality: sum(row["quality"] == quality for row in rows) + for quality in ("accepted", "partial", "rejected")}, + "tolerances": {"volume_relative": VOLUME_RTOL, "volume_absolute": VOLUME_ATOL, + "bbox_relative_to_axis_span": BBOX_RTOL, "bbox_absolute": BBOX_ATOL, + "symmetric_difference_relative": DIFFERENCE_RTOL}, + "volume_method": "Gauss-Kronrod, epsilon=1e-9, closed shells, BSpline spans", + "area_method": "Independent geometry copy, C1 continuity spans, adaptive epsilon=1e-10", + "reference_step_dir": str(reference_step_dir) if reference_step_dir else None, + "reference_python": reference_python} diff --git a/tools/research/build123dftc/build123d_profile.py b/tools/research/build123dftc/build123d_profile.py new file mode 100644 index 00000000..52467f1e --- /dev/null +++ b/tools/research/build123dftc/build123d_profile.py @@ -0,0 +1,44 @@ +"""Stage 4: count actual traced operations and report conversion gaps.""" +import argparse +from collections import Counter +import json +from pathlib import Path + + +def profile_traces(paths): + operations, sources, unsupported = Counter(), Counter(), Counter() + rows = [] + for path in paths: + trace = json.loads(Path(path).read_text(encoding="utf-8")) + for step in trace.get("steps", []): + operations[step["op"]] += 1 + sources[step.get("source", step["op"])] += 1 + for note in trace.get("unsupported", []): + unsupported[note.get("reason", str(note)) if isinstance(note, dict) else str(note)] += 1 + rows.append({"stem": trace.get("stem", Path(path).name.removesuffix(".trace.json")), + "status": trace.get("b3d_status"), "steps": len(trace.get("steps", [])), + "unsupported": len(trace.get("unsupported", []))}) + return {"model_count": len(rows), "operations": dict(operations.most_common()), + "source_methods": dict(sources.most_common()), "unsupported": dict(unsupported.most_common()), "rows": rows} + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--traces-dir", required=True) + parser.add_argument("--report") + args = parser.parse_args(argv) + paths = sorted(Path(args.traces_dir).glob("*.trace.json")) + if not paths: + parser.error("no traces found") + report = profile_traces(paths) + text = json.dumps(report, ensure_ascii=False, indent=2) + "\n" + if args.report: + path = Path(args.report) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text, encoding="utf-8") + print(text) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/research/build123dftc/build123d_to_ftc.py b/tools/research/build123dftc/build123d_to_ftc.py new file mode 100644 index 00000000..0ae979a5 --- /dev/null +++ b/tools/research/build123dftc/build123d_to_ftc.py @@ -0,0 +1,66 @@ +"""Stage 2: translate portable build123d traces into native FTC Python.""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + + +def safe_stem(stem): + if not isinstance(stem, str) or stem in ("", ".", "..") or any(c in stem for c in ("/", "\\", "\x00", "\n", "\r")): + raise ValueError("stem must be a single nonempty filename") + return stem + + +def translate_trace_file(trace_path: Path, out_dir: Path, *, constraints_mode=False): + from b3ftc.replay import replay_trace_to_ftc + from b3ftc.schema import SCHEMA_VERSION + payload = json.loads(trace_path.read_text(encoding="utf-8")) + stem = safe_stem(payload.get("stem", trace_path.name.removesuffix(".trace.json"))) + if payload.get("schema_version") != SCHEMA_VERSION: + raise ValueError(f"unsupported trace schema: {payload.get('schema_version')!r}") + options = {"constraints_mode": True} if constraints_mode else {} + source, meta = replay_trace_to_ftc(payload, stem=stem, **options) + meta = {"stem": stem, "source_file": payload.get("source_file"), **meta} + snapshots = meta.pop("sketches", []) + out_dir.mkdir(parents=True, exist_ok=True) + (out_dir / f"{stem}.ftc.py").write_text(source, encoding="utf-8") + (out_dir / f"{stem}.meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8") + (out_dir / f"{stem}.sketches.json").write_text(json.dumps({"stem": stem, "constraints_mode": constraints_mode, "sketches": snapshots}, + ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8") + return stem, source, meta + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + inputs = parser.add_mutually_exclusive_group(required=True) + inputs.add_argument("--trace") + inputs.add_argument("--traces-dir") + parser.add_argument("--out", default="tools/research/build123dftc/out/ftc") + parser.add_argument("--constraints", choices=("on", "off"), default="off", help="recover inferred constraints with the existing CQ engine") + args = parser.parse_args(argv) + paths = [Path(args.trace)] if args.trace else sorted(Path(args.traces_dir).glob("*.trace.json")) + if not paths: + parser.error("no traces found") + failed = 0 + for path in paths: + try: + stem, source, meta = translate_trace_file(path, Path(args.out), constraints_mode=args.constraints == "on") + failed += meta["status"] != "ok" + print(f"{stem}: {meta['status']} ({meta.get('feature_count', 0)} features, {len(meta.get('unsupported', []))} unsupported)", flush=True) + except Exception as error: + failed += 1 + stem = safe_stem(path.name.removesuffix(".trace.json")) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + (out / f"{stem}.meta.json").write_text(json.dumps({"stem": stem, "status": "error", "unsupported": [f"{type(error).__name__}: {error}"]}, indent=2) + "\n") + print(f"{stem}: translation_error: {type(error).__name__}: {error}", flush=True) + print(f"translated {len(paths)} traces, {failed} incomplete -> {args.out}") + return 1 if failed else 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/research/build123dftc/build123d_trace.py b/tools/research/build123dftc/build123d_trace.py new file mode 100644 index 00000000..23c1f078 --- /dev/null +++ b/tools/research/build123dftc/build123d_trace.py @@ -0,0 +1,121 @@ +"""Stage 1: execute trusted build123d models in isolated worker processes.""" +from __future__ import annotations + +import argparse +import json +import math +import os +from pathlib import Path +import signal +import subprocess +import sys + +TOOLS = Path(__file__).resolve().parent +sys.path.insert(0, str(TOOLS)) +from b3ftc.schema import empty_trace + + +def discover_inputs(*, input_file=None, inputs_dir=None, manifest=None): + if input_file: + paths = [Path(input_file).resolve()] + elif manifest: + path = Path(manifest).resolve() + payload = json.loads(path.read_text(encoding="utf-8")) + paths = [(path.parent / item["file"]).resolve() for item in payload["examples"]] + elif inputs_dir: + paths = sorted(Path(inputs_dir).resolve().glob("*.py")) + else: + raise ValueError("one input source is required") + if not paths: + raise ValueError("no Python models found") + if any(not p.is_file() for p in paths): + raise FileNotFoundError("some declared model files do not exist") + stems = [p.stem for p in paths] + if len(set(stems)) != len(stems): + raise ValueError("model stems must be unique within one batch") + return paths + + +def trace_model(path: Path, out_dir: Path, *, stem=None, timeout=120, python_executable=None, source_metadata=None): + from build123d_to_ftc import safe_stem + if not math.isfinite(timeout) or timeout <= 0: + raise ValueError("timeout must be finite and positive") + path = path.resolve() + stem = safe_stem(stem or path.stem) + out_dir.mkdir(parents=True, exist_ok=True) + output = out_dir / f"{stem}.trace.json" + temporary = out_dir / f"{stem}.trace.tmp.json" + log_path = out_dir / f"{stem}.trace.log" + temporary.unlink(missing_ok=True) + command = [python_executable or sys.executable, str(TOOLS / "b3ftc/_trace_worker.py"), + str(path), str(temporary.resolve())] + with log_path.open("w", encoding="utf-8") as log: + process = subprocess.Popen(command, stdout=log, stderr=log, cwd=path.parent, + start_new_session=True) + try: + code = process.wait(timeout=timeout) + failure = f"trace worker exited with code {code}" if code else "" + except subprocess.TimeoutExpired: + if os.name == "posix": + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + else: + process.kill() + process.wait() + failure = f"source execution timed out after {timeout}s" + if failure or not temporary.exists(): + payload = empty_trace() + payload.update(b3d_status="error", source_file=str(path), error=failure or "worker produced no trace") + with log_path.open("rb") as log: + log.seek(max(0, log_path.stat().st_size - 4096)) + payload["error"] += "\n" + log.read().decode("utf-8", errors="replace") + else: + payload = json.loads(temporary.read_text(encoding="utf-8")) + payload["stem"] = stem + if source_metadata: + payload["source_metadata"] = source_metadata + temporary.write_text(json.dumps(payload, ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8") + temporary.replace(output) + return payload + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + inputs = parser.add_mutually_exclusive_group(required=True) + inputs.add_argument("--input", dest="input_file", help="one trusted Python source") + inputs.add_argument("--inputs-dir", "--dataset", dest="inputs_dir", help="directory of Python models") + inputs.add_argument("--manifest", help="JSON examples manifest, paths relative to manifest") + parser.add_argument("--out", default="tools/research/build123dftc/out/traces") + parser.add_argument("--stem", help="output stem for one source") + parser.add_argument("--timeout", type=float, default=120) + parser.add_argument("--limit", type=int) + parser.add_argument("--python", dest="python_executable", help="interpreter with build123d installed") + args = parser.parse_args(argv) + if not math.isfinite(args.timeout) or args.timeout <= 0 or (args.limit is not None and args.limit <= 0): + parser.error("timeout and limit must be positive") + if args.stem and not args.input_file: + parser.error("--stem requires --input") + paths = discover_inputs(input_file=args.input_file, inputs_dir=args.inputs_dir, manifest=args.manifest) + metadata = {} + if args.manifest: + manifest_path = Path(args.manifest).resolve() + manifest = json.loads(manifest_path.read_text(encoding="utf-8")) + metadata = {str((manifest_path.parent / row["file"]).resolve()): + {key: row[key] for key in ("source_url", "source_sha256", "export_options") if key in row} + for row in manifest["examples"]} + paths = paths[:args.limit] if args.limit else paths + failed = 0 + for path in paths: + row = trace_model(path, Path(args.out), stem=args.stem, timeout=args.timeout, + python_executable=args.python_executable, source_metadata=metadata.get(str(path))) + failed += row["b3d_status"] != "ok" + print(f"{row['stem']}: {row['b3d_status']} ({len(row['steps'])} operations, " + f"{len(row['unsupported'])} unsupported)", flush=True) + print(f"captured {len(paths)} models, {failed} failed -> {args.out}") + return 1 if failed else 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/research/build123dftc/build123d_validate.py b/tools/research/build123dftc/build123d_validate.py new file mode 100644 index 00000000..c0632463 --- /dev/null +++ b/tools/research/build123dftc/build123d_validate.py @@ -0,0 +1,45 @@ +"""Stage 3 — validate generated FTC solids against source traces and optional STEP.""" +from __future__ import annotations + +import argparse +import json +import math +from pathlib import Path + +from b3ftc.validation import validate_directory + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--ftc-dir", type=Path, required=True) + parser.add_argument("--traces-dir", type=Path, required=True) + parser.add_argument("--report", type=Path) + parser.add_argument("--timeout", type=float, default=120) + parser.add_argument("--reference-step-dir", type=Path) + parser.add_argument("--reference-python", help="Optional independent OCCT interpreter for STEP differences") + parser.add_argument("--limit", type=int) + parser.add_argument("--python", dest="python_executable", help="SimpleCADAPI worker interpreter") + args = parser.parse_args(argv) + if not args.ftc_dir.is_dir() or not args.traces_dir.is_dir(): + parser.error("--ftc-dir and --traces-dir must be existing directories") + if not math.isfinite(args.timeout) or args.timeout <= 0: + parser.error("--timeout must be positive and finite") + if args.limit is not None and args.limit < 0: + parser.error("--limit must be nonnegative") + if args.reference_python and not args.reference_step_dir: + parser.error("--reference-python requires --reference-step-dir") + report = validate_directory(args.ftc_dir, args.traces_dir, timeout=args.timeout, + reference_step_dir=args.reference_step_dir, limit=args.limit, + python_executable=args.python_executable, + reference_python=args.reference_python) + for row in report["rows"]: + print(f"{row['stem']}: {row['quality']} (build={row['build']}, reasons={','.join(row['reasons']) or 'none'})") + print(json.dumps(report["counts"])) + if args.report is not None: + args.report.parent.mkdir(parents=True, exist_ok=True) + args.report.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n") + return 0 if report["rows"] and not (report["counts"]["rejected"] or report["counts"]["partial"]) else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/research/build123dftc/research/inspect_api.py b/tools/research/build123dftc/research/inspect_api.py new file mode 100644 index 00000000..7fc65ac4 --- /dev/null +++ b/tools/research/build123dftc/research/inspect_api.py @@ -0,0 +1,328 @@ +"""Generate a version-specific public build123d API and corpus inventory. + +This is research evidence, not a declaration that conversion is implemented. +Run with the same interpreter as the source model corpus. +""" + +from __future__ import annotations + +import argparse +import ast +from collections import Counter +from enum import Enum +import inspect +import hashlib +import json +from pathlib import Path +from typing import Any + + +DOCUMENTATION_SOURCES = [ + "https://build123d.readthedocs.io/en/v0.13.0/objects.html", + "https://build123d.readthedocs.io/en/v0.13.0/operations.html", + "https://build123d.readthedocs.io/en/v0.13.0/key_concepts_builder.html", + "https://build123d.readthedocs.io/en/v0.13.0/key_concepts_algebra.html", + "https://build123d.readthedocs.io/en/v0.13.0/direct_api_reference.html", +] + +OPERATORS = { + "__add__", "__radd__", "__sub__", "__and__", "__mul__", "__rmul__", + "__matmul__", "__xor__", "__mod__", "__neg__", "__invert__", +} +TRANSFORMS = { + "move", "moved", "locate", "located", "translate", "rotate", "scale", + "mirror", "transform_shape", "transform_geometry", "transformed", +} +FEATURES = { + "extrude", "extrude_taper", "extrude_until", "extrude_linear_with_rotation", + "revolve", "sweep", "sweep_multi", "loft", "fillet", "chamfer", "draft", + "hollow", "offset", "offset_2d", "offset_3d", "split", "split_by_perimeter", + "thicken", "dprism", "trim", "trim_infinite", "trim_to_length", + "trim_to_other", "make_holes", "without_holes", "close", "stitch", "combine", + "clean", "fix", "fix_degenerate_edges", "to_splines", "reversed", "wrap", + "wrap_faces", "cut", "fuse", "intersect", "fillet_2d", "chamfer_2d", + "project", "project_to_shape", "project_faces", "sew_faces", +} + + +def category(name: str, obj: Any) -> str: + module = getattr(obj, "__module__", "") + if inspect.isclass(obj) and issubclass(obj, Enum): + return "enum" + if module.startswith("build123d.operations_"): + return "operation" + if module.startswith("build123d.objects_"): + return "object_" + module.removeprefix("build123d.objects_") + if name.startswith("Build"): + return "builder" + if name.endswith("Locations") or name == "Locations": + return "locations" + if module.startswith("build123d.topology"): + return "direct_topology" + if module == "build123d.geometry": + return "geometry" + if "export" in module or name.startswith("Export"): + return "export" + if "import" in module or name.startswith("import_"): + return "import" + if module == "build123d.joints": + return "assembly_joint" + if module == "build123d.drafting": + return "drawing_object" + if not callable(obj): + return "constant_or_type_alias" + return "utility" + + +def source_info(obj: Any, package_dir: Path) -> dict[str, Any]: + result: dict[str, Any] = {} + try: + source = Path(inspect.getsourcefile(obj) or "") + result["source_file"] = str(source.relative_to(package_dir.parent)) + result["source_line"] = inspect.getsourcelines(obj)[1] + except (TypeError, ValueError, OSError): + pass + try: + result["signature"] = str(inspect.signature(obj)) + except (TypeError, ValueError): + pass + return result + + +def member_category(name: str, raw: Any, owner: type) -> str: + if isinstance(raw, property): + return "property" + if name in OPERATORS: + return "algebra_operator" + if name in TRANSFORMS: + return "transform" + if name.startswith("make_") or name == "from_bounding_box": + return "factory" + if name in FEATURES: + return "feature" + if name in {"__enter__", "__exit__"}: + return "context_lifecycle" + if issubclass(owner, Enum): + return "enum_member" + return "query_or_utility" + + +class ModelVisitor(ast.NodeVisitor): + """Count modeling calls, excluding entrypoint and constant-false docs branches.""" + + def __init__(self, exports: set[str]): + self.exports = exports + self.constants: dict[str, Any] = {} + self.calls: Counter[str] = Counter() + self.methods: Counter[str] = Counter() + self.operators: Counter[str] = Counter() + self.builders = False + self.aliases = {"build123d"} + + def visit_Import(self, node: ast.Import) -> None: + for alias in node.names: + if alias.name == "build123d": + self.aliases.add(alias.asname or alias.name) + + def visit_Assign(self, node: ast.Assign) -> None: + if isinstance(node.value, ast.Constant): + for target in node.targets: + if isinstance(target, ast.Name): + self.constants[target.id] = node.value.value + self.generic_visit(node) + + def visit_If(self, node: ast.If) -> None: + test = node.test + is_entrypoint = ( + isinstance(test, ast.Compare) + and isinstance(test.left, ast.Name) + and test.left.id == "__name__" + ) + if is_entrypoint: + return + if isinstance(test, ast.Name) and self.constants.get(test.id) is False: + for stmt in node.orelse: + self.visit(stmt) + return + self.generic_visit(node) + + def visit_Call(self, node: ast.Call) -> None: + func = node.func + if isinstance(func, ast.Name) and func.id in self.exports: + self.calls[func.id] += 1 + self.builders |= func.id in {"BuildLine", "BuildSketch", "BuildPart"} + elif isinstance(func, ast.Attribute): + if isinstance(func.value, ast.Name) and func.value.id in self.aliases: + self.calls[func.attr] += 1 + self.builders |= func.attr in {"BuildLine", "BuildSketch", "BuildPart"} + else: + self.methods[func.attr] += 1 + self.generic_visit(node) + + def visit_BinOp(self, node: ast.BinOp) -> None: + self.operators[type(node.op).__name__] += 1 + self.generic_visit(node) + + +def inventory(manifest_path: Path) -> dict[str, Any]: + import build123d as bd + from build123d.build_common import BaseObjectMeta, Builder + from build123d.topology.shape_core import Shape + from build123d.topology.one_d import Mixin1D + from build123d.topology.two_d import Mixin2D + from build123d.topology.three_d import Mixin3D + + package_dir = Path(bd.__file__).parent + manifest = json.loads(manifest_path.read_text()) + top_level: list[dict[str, Any]] = [] + members: dict[str, dict[str, Any]] = {} + classes: dict[str, list[str]] = {} + extra_classes = [Shape, Mixin1D, Mixin2D, Mixin3D, Builder, BaseObjectMeta] + for name in bd.__all__: + obj = getattr(bd, name) + record = { + "name": name, + "kind": "class" if inspect.isclass(obj) else "function" if callable(obj) else "value", + "category": category(name, obj), + "module": getattr(obj, "__module__", type(obj).__module__), + "conversion_status": "unverified", + **source_info(obj, package_dir), + } + if inspect.isclass(obj) and issubclass(obj, Enum): + record["values"] = list(obj.__members__) + top_level.append(record) + if inspect.isclass(obj): + extra_classes.append(obj) + for cls in dict.fromkeys(extra_classes): + refs = [] + for name in sorted(dir(cls)): + if name.startswith("_") and name not in OPERATORS | {"__enter__", "__exit__", "__call__"}: + continue + owner = next((parent for parent in cls.__mro__ if name in vars(parent)), None) + if owner is None or not owner.__module__.startswith("build123d"): + continue + raw = vars(owner)[name] + value = raw.fget if isinstance(raw, property) else raw.__func__ if isinstance(raw, (staticmethod, classmethod)) else raw + if not callable(value) and not isinstance(raw, property): + continue + key = owner.__module__ + "." + owner.__name__ + "." + name + refs.append(key) + if key not in members: + members[key] = { + "name": name, + "owner": owner.__module__ + "." + owner.__name__, + "category": member_category(name, raw, owner), + "descriptor": "property" if isinstance(raw, property) else "classmethod" if isinstance(raw, classmethod) else "staticmethod" if isinstance(raw, staticmethod) else "method", + "conversion_status": "unverified", + **source_info(value, package_dir), + } + classes[cls.__module__ + "." + cls.__name__] = refs + models = [] + all_calls: Counter[str] = Counter() + all_methods: Counter[str] = Counter() + for item in manifest["examples"]: + model_path = manifest_path.parent / item["file"] + visitor = ModelVisitor(set(bd.__all__)) + visitor.visit(ast.parse(model_path.read_text())) + all_calls.update(visitor.calls) + all_methods.update(visitor.methods) + models.append({ + "id": item["id"], "name": item["name"], "file": item["file"], + "source_url": item["source_url"], + "builder_context_present": visitor.builders, + "top_level_call_sites": dict(visitor.calls.most_common()), + "method_call_sites": dict(visitor.methods.most_common()), + "operator_syntax_counts": dict(visitor.operators.most_common()), + }) + return { + "schema_version": 1, + "purpose": "Version-specific API inventory and static source corpus evidence; unverified is not implemented support.", + "build123d_version": bd.__version__, + "corpus_tag": manifest["tag"], + "corpus_commit": manifest["commit"], + "sources": DOCUMENTATION_SOURCES, + "scope": "203 package __all__ exports plus public build123d-declared members reachable through these classes, Shape, topology mixins and Builder; Python/OCP internals are excluded.", + "counts": { + "top_level_exports": len(top_level), "unique_public_member_declarations": len(members), + "class_interfaces": len(classes), "corpus_models": len(models), + "corpus_distinct_top_level_calls": len(all_calls), + "corpus_top_level_call_sites": sum(all_calls.values()), + "top_level_by_category": dict(Counter(item["category"] for item in top_level)), + "members_by_category": dict(Counter(item["category"] for item in members.values())), + }, + "top_level_api": top_level, + "members": members, + "class_members": classes, + "corpus": { + "counting_note": "AST call sites, not runtime execution counts. Constant-false GEN_DOCS branches and __main__ export blocks are omitted; loops/functions are counted syntactically. Operator counts include numeric arithmetic.", + "top_level_calls": dict(all_calls.most_common()), + "method_calls": dict(all_methods.most_common()), + "models": models, + }, + } + + +def validation_evidence(data: dict[str, Any], report_path: Path, traces_dir: Path | None) -> None: + """Link only verified samples, never promote an entire API parameter space.""" + report = json.loads(report_path.read_text()) + rows = {row["stem"]: row for row in report["rows"]} + accepted = {stem for stem, row in rows.items() if row.get("quality") == "accepted"} + usage: dict[str, set[str]] = {} + for model in data["corpus"]["models"]: + stem = Path(model["file"]).stem + for api in model["top_level_call_sites"]: + usage.setdefault(api, set()).add(stem) + observed_members: dict[str, set[str]] = {} + if traces_dir is not None: + for path in traces_dir.glob("*.trace.json"): + stem = path.name.removesuffix(".trace.json") + trace = json.loads(path.read_text()) + for step in trace.get("steps", []): + source = step.get("source") + if source and step.get("op") != "unsupported": + observed_members.setdefault(source, set()).add(stem) + source_report = {"path": str(report_path), + "sha256": hashlib.sha256(report_path.read_bytes()).hexdigest()} + for record in data["top_level_api"]: + exercised = usage.get(record["name"], set()) + verified = sorted(exercised & accepted) + if verified: + record["conversion_status"] = "verified_sampled_usage" + record["validation_evidence"] = { + "accepted_models": verified, + "rejected_or_unverified_models": sorted(exercised - accepted), + "scope": "Model-level evidence for the listed source calls only; other argument variants remain unverified.", + } + for record in data["members"].values(): + source = record["owner"].rsplit(".", 1)[-1] + "." + record["name"] + exercised = observed_members.get(source, set()) + verified = sorted(exercised & accepted) + if verified: + record["conversion_status"] = "verified_sampled_usage" + record["validation_evidence"] = {"accepted_models": verified, + "scope": "Captured member call in accepted models; other argument variants remain unverified."} + data["verification"] = {"source_report": source_report, + "accepted_models": sorted(accepted), + "rejected_or_unverified_models": sorted(set(rows) - accepted), + "scope": "Sample-level acceptance is not a claim of all-API or all-parameter coverage.", + "verified_top_level_entries": sum(r["conversion_status"] == "verified_sampled_usage" for r in data["top_level_api"]), + "verified_public_member_entries": sum(r["conversion_status"] == "verified_sampled_usage" for r in data["members"].values())} + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--manifest", type=Path, required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--validation-report", type=Path, help="Optional strict stage-3 report for sample evidence") + parser.add_argument("--traces-dir", type=Path, help="Trace source member names supporting the validation report") + args = parser.parse_args() + data = inventory(args.manifest.resolve()) + if args.validation_report is not None: + validation_evidence(data, args.validation_report, args.traces_dir) + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n") + print(json.dumps(data["counts"], indent=2, ensure_ascii=False)) + + +if __name__ == "__main__": + main()