ra.transform

Move, rotate, scale, mirror, arrays, deformations (bend, twist, taper), flow, placement on objects.

import rhinoartisan as ra

Wraps ArtisanPlugin.Scripting.TransformApi.

Functions

Function
array_linear()	Copies the objects count times in total (original included) along step: copy i sits at i * step.
array_on_curve()	The ArtisanArrayOnCurve panel, headless: distributes copies of the objects along curve_id, each copy reoriented to the curve’s perpendicular frame (the objects are expected modeled around the world origin on the XY plane, like the panel).
array_polar()	The ArtisanArrayPolar panel, headless: revolves the objects around the axis of plane (“TOP” = around world Z, “FRONT” = around Y, “SIDE” = around X, “CPLANE” = the active viewport’s construction plane), copies per row over angle degrees (alignment JUSTIFY spreads over the full 360 regardless of angle; LEFT/CENTER/RIGHT start the sweep before/around/after the original).
bend()	Bends the objects around their bounding-box center (the ArtisanBend tool, headless).
center()	The ArtisanCenter command, headless: translates the objects, as one set, so the center of their common world-axis bounding box lands on the world origin (0,0,0).
copies()	The ArtisanCopies command, headless: duplicates the objects count times (1..100; 0 = 1) along -Y for a production tray, each copy one selection-height further (the union bounding box’s Y extent), so multi-object models keep their parts together and the copies touch edge to edge.
copy_on_objects()	The ArtisanCopyOnObjects command, headless: copies the objects onto the target objects, once per point in points (each point replicates one click of the command; the command loops until Enter).
distribute()	The ArtisanDistribute command, headless: lays the objects out in a row along +X for a print/casting tray — each piece resting on Z = 0 with its back edge on Y = 0, left edges chained with a 10 % gap of each piece’s width.
duplicate()	Duplicates the objects in place (a copy on top of each original) — the starting point of “duplicate and vary” Flow recipes.
flow_by_curve()	The ArtisanSmartFlowbyCurve panel, headless: flows the objects from base_curve_id onto target_curve_id (Rhino’s Flow space morph).
flow_by_surface()	The ArtisanSmartFlowbySurface panel, headless: flows the objects from base_surface_id onto target_surface_id (Rhino’s Sporph space morph; the first face of a polysurface/extrusion is used, like the panel).
mirror()	Mirrors the objects across a world plane through origin (None = the world origin): “XY”, “YZ” or “XZ”.
mirror_opposite()	The ArtisanMirrorOpposite command, headless: places one copy of each object on the opposite side of plane’s origin (None = the active viewport’s construction plane, like the command; world XY when there is no view).
mirror_quad()	The ArtisanMirrorQuad command, headless: mirrors the objects into the other three quadrants of plane (None = the active viewport’s construction plane, like the command; world XY when there is no view).
move()	Translates the objects by translation mm.
move_by_normal()	The ArtisanMoveByNormal command, headless: moves each object along the normal of surface_id — evaluated at the surface point closest to the object’s bounding-box center, so each object follows its own local normal — by distance mm (the command’s initial default is 1.0; negative moves against the normal).
move_on_objects()	The ArtisanMoveOnObjects command, headless: same placement math as CopyOnObjects (same base mesh, same per-object frame from the mesh point and normal closest to the bounding-box center) but the objects are MOVED in place onto the single point (pulled onto the base mesh first, like the command’s cursor constraint).
move_random()	The ArtisanMoveRandom command, headless: moves EACH object by distance mm along its own random unit direction (a different direction per object), to break the perfect regularity of pave stones or beads.
orient_on_surface()	The ArtisanOrientOnSurface command, headless: copies the objects onto surface_id (a surface/polysurface/extrusion), once per point in points (each point = one click of the command).
rotate()	Rotates the objects angle_degrees around axis (“X”, “Y” or “Z”, world-oriented) through center (None = the center of the common bounding box, so the selection spins in place).
scale()	Scales the objects by factor about center (None = the center of the common bounding box).
scale_by_center()	The ArtisanScaleByCenter command, headless: scales the objects uniformly by factor (> 0; 1 = no change) about the center of their common bounding box, so the set grows/shrinks in place.
scale_by_weight()	Uniformly scales the objects so they weigh exactly target_grams when cast in metal (the ArtisanScaleByWeight tool, headless).
scale_to_dimensions()	The ArtisanScaleByDimensions panel, headless: scales the objects (as one set, about the center of their common world-axis bounding box) so that box measures exactly the given sizes, in mm.
taper()	Tapers the objects along a bounding-box axis (the ArtisanTaper tool, headless): the section grows/shrinks linearly toward the “Top” end of the axis - tapered shanks, cone-ing a motif.
twist()	Twists the objects angle_degrees around a bounding-box axis (the ArtisanTwist tool, headless) - rope-like shanks, twisted wires, spiral motifs.

ra.transform.array_linear()

ra.transform.array_linear(object_ids=None, count=None, step=None) -> List[str]

Copies the objects count times in total (original included) along step: copy i sits at i * step. Returns the ids of the created copies ((count - 1) x objects).

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
count	int	optional — None = the tool default
step	Optional[VectorLike]	optional — None = the tool default

ra.transform.array_on_curve()

ra.transform.array_on_curve(object_ids=None, curve_id=None, copies=None, distance=None, alignment=None, mode=None, rotation=None, move_in_z=None, surface_ids=None, keep_original=None) -> List[str]

The ArtisanArrayOnCurve panel, headless: distributes copies of the objects along curve_id, each copy reoriented to the curve’s perpendicular frame (the objects are expected modeled around the world origin on the XY plane, like the panel). With surface_ids the frames also lean on those objects’ render mesh normal — the panel’s optional base surface, for arrays that hug a shank. alignment START/CENTER/END packs the run with distance mm between copies; JUSTIFY spreads copies evenly over the whole curve and ignores distance. mode END keeps the copies’ ends inside the curve, CENTER lets the first/last centers sit on the curve ends. rotation (degrees, around the running axis) and moveInZ (mm) offset every copy. keep_original False deletes the source objects (the panel’s default). Returns the ids of the created copies (copies x objects).

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
curve_id	Optional[IdLike]	optional — None = the tool default
copies	int	optional — None = the tool default
distance	float	optional — None = the tool default
alignment	str	optional — None = the tool default
mode	str	optional — None = the tool default
rotation	float	optional — None = the tool default
move_in_z	float	optional — None = the tool default
surface_ids	Sequence[IdLike]	optional — None = the tool default
keep_original	bool	optional — None = the tool default

ra.transform.array_polar()

ra.transform.array_polar(object_ids=None, copies=None, angle=None, plane=None, alignment=None, mode=None, rows=None, rows_distance=None, both_sides=None, keep_original=None) -> List[str]

The ArtisanArrayPolar panel, headless: revolves the objects around the axis of plane (“TOP” = around world Z, “FRONT” = around Y, “SIDE” = around X, “CPLANE” = the active viewport’s construction plane), copies per row over angle degrees (alignment JUSTIFY spreads over the full 360 regardless of angle; LEFT/CENTER/RIGHT start the sweep before/around/after the original). mode adds rows (“ONE” single row; “MULTI”/“MULTI_INTER” stack rows every rows_distance mm along the axis, INTER staggering odd rows half a step; the SPHERICAL variants wrap the rows around the axis origin instead — for domed pave). both_sides mirrors the extra rows below the first. keep_original False deletes the source objects (the panel’s default: the first JUSTIFY copy lands on the original). Returns the ids of the created copies.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
copies	int	optional — None = the tool default
angle	float	optional — None = the tool default
plane	str	optional — None = the tool default
alignment	str	optional — None = the tool default
mode	str	optional — None = the tool default
rows	int	optional — None = the tool default
rows_distance	float	optional — None = the tool default
both_sides	bool	optional — None = the tool default
keep_original	bool	optional — None = the tool default

ra.transform.bend()

ra.transform.bend(object_ids: Sequence[IdLike], x_pos=None, x_neg=None, y_pos=None, y_neg=None, plane=None, rigid_ids=None, keep_original=None) -> List[str]

Bends the objects around their bounding-box center (the ArtisanBend tool, headless). The jewelry move: curve a flat motif so it wraps the finger - e.g. bend a flat band or pattern around the ring curvature before a flow/boolean. For that, bend on the default “XY” plane with equal x_pos/x_neg and the amount that matches the finger diameter (see ra.document.get_ring_size().Diameter). x_pos, x_neg, y_pos, y_neg are how far (mm) each side of the bounding box is pushed along the bend plane’s normal - exactly the four gumball handles of the panel. Positive lifts toward the plane normal, negative bends the other way, 0 leaves that side straight. At least one must be non-zero. Pass the same value to a pair for a symmetric bend (the panel’s Symmetrical / Quad modes just mirror one handle onto the others). plane is the bend plane: “XY” (default, bends up in Z), “ZX” or “YZ”. Returns the new object ids.

Parameter	Type
object_ids	Sequence[IdLike]	required
x_pos	float	optional — None = the tool default
x_neg	float	optional — None = the tool default
y_pos	float	optional — None = the tool default
y_neg	float	optional — None = the tool default
plane	str	optional — None = the tool default
rigid_ids	Sequence[IdLike]	optional — None = the tool default
keep_original	bool	optional — None = the tool default

ra.transform.center()

ra.transform.center(object_ids=None) -> List[str]

The ArtisanCenter command, headless: translates the objects, as one set, so the center of their common world-axis bounding box lands on the world origin (0,0,0). In-place move; the arrangement between the objects is kept. Returns the ids of the moved objects.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default

ra.transform.copies()

ra.transform.copies(object_ids=None, count=None) -> List[str]

The ArtisanCopies command, headless: duplicates the objects count times (1..100; 0 = 1) along -Y for a production tray, each copy one selection-height further (the union bounding box’s Y extent), so multi-object models keep their parts together and the copies touch edge to edge. Returns the ids of the copies (count x objects), in copy-major order.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
count	int	optional — None = the tool default

ra.transform.copy_on_objects()

ra.transform.copy_on_objects(object_ids: Sequence[IdLike], target_ids: Sequence[IdLike], points: Sequence[PointLike]) -> List[str]

The ArtisanCopyOnObjects command, headless: copies the objects onto the target objects, once per point in points (each point replicates one click of the command; the command loops until Enter). The frame is derived exactly like the command does: the targets are meshed (render-quality) into one base mesh; for each object, the mesh point and face normal closest to the object’s bounding-box center define the origin plane, and the same offset applied at the picked point defines the destination plane — so a group of objects keeps its arrangement and each copy reorients to the surface normal. Points are pulled onto the base mesh first, like the command’s cursor constraint. Plain copies, no history/parametric link (the command records none). Returns the ids of the created copies (points x objects), in point-major order.

Parameter	Type
object_ids	Sequence[IdLike]	required
target_ids	Sequence[IdLike]	required
points	Sequence[PointLike]	required

ra.transform.distribute()

ra.transform.distribute(object_ids=None) -> List[str]

The ArtisanDistribute command, headless: lays the objects out in a row along +X for a print/casting tray — each piece resting on Z = 0 with its back edge on Y = 0, left edges chained with a 10 % gap of each piece’s width. Objects sharing a Rhino group travel together as ONE piece (a ring + its gems is not dismembered); ungrouped objects are a piece each. Order = the order of the ids. In-place move; returns the ids moved.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default

ra.transform.duplicate()

ra.transform.duplicate(object_ids=None) -> List[str]

Duplicates the objects in place (a copy on top of each original) — the starting point of “duplicate and vary” Flow recipes. Returns the ids of the copies.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default

ra.transform.flow_by_curve()

ra.transform.flow_by_curve(deformable_ids: Sequence[IdLike], base_curve_id: IdLike, target_curve_id: IdLike, rigid_ids=None, flip_base=None) -> List[str]

The ArtisanSmartFlowbyCurve panel, headless: flows the objects from base_curve_id onto target_curve_id (Rhino’s Flow space morph). deformable_ids are morphed (a shank, a pattern…); rigid_ids keep their shape and are only re-placed along the curve (gems, settings). At least one of the two lists is required. flip_base reverses the base curve direction (the panel’s flip button) when the result lands mirrored. Same bake as the panel’s Accept: the originals stay, the deformed copies keep the source layer/material and carry Rhino history (editing either curve or the source re-flows them); rigid copies are TransformWithHistory copies. Returns the ids of the created copies (deformed first, then rigid).

Parameter	Type
deformable_ids	Sequence[IdLike]	required
base_curve_id	IdLike	required
target_curve_id	IdLike	required
rigid_ids	Sequence[IdLike]	optional — None = the tool default
flip_base	bool	optional — None = the tool default

ra.transform.flow_by_surface()

ra.transform.flow_by_surface(deformable_ids: Sequence[IdLike], base_surface_id: IdLike, target_surface_id: IdLike, rigid_ids=None, base_orientation=None, target_orientation=None) -> List[str]

The ArtisanSmartFlowbySurface panel, headless: flows the objects from base_surface_id onto target_surface_id (Rhino’s Sporph space morph; the first face of a polysurface/extrusion is used, like the panel). deformable_ids are morphed, rigid_ids keep their shape and are re-placed frame-to-frame (gems, settings); at least one of the two lists is required. base_orientation / target_orientation are the panel’s UV combos: “None” (default), “ReverseU”, “ReverseV” or “SwapUV” — use them when the result lands mirrored or rotated. Same bake as the Accept: originals stay, copies keep the source layer/material and carry Rhino history. Returns the ids of the created copies (deformed first, then rigid).

Parameter	Type
deformable_ids	Sequence[IdLike]	required
base_surface_id	IdLike	required
target_surface_id	IdLike	required
rigid_ids	Sequence[IdLike]	optional — None = the tool default
base_orientation	str	optional — None = the tool default
target_orientation	str	optional — None = the tool default

ra.transform.mirror()

ra.transform.mirror(object_ids=None, plane=None, origin=None, copy=None) -> List[str]

Mirrors the objects across a world plane through origin (None = the world origin): “XY”, “YZ” or “XZ”. Unlike the two jewelry mirrors (MirrorQuad/MirrorOpposite) this is the plain mirror, plain copies without history. copy False mirrors in place.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
plane	str	optional — None = the tool default
origin	Optional[PointLike]	optional — None = the tool default
copy	bool	optional — None = the tool default

ra.transform.mirror_opposite()

ra.transform.mirror_opposite(object_ids=None, plane=None) -> List[str]

The ArtisanMirrorOpposite command, headless: places one copy of each object on the opposite side of plane’s origin (None = the active viewport’s construction plane, like the command; world XY when there is no view). The two mirrors compose into a 180-degree rotation around the plane’s vertical axis, so the copy keeps its handedness. History-linked copies, like the command. Returns the ids of the created copies (1 per object).

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
plane	Optional[PlaneLike]	optional — None = the tool default

ra.transform.mirror_quad()

ra.transform.mirror_quad(object_ids=None, plane=None) -> List[str]

The ArtisanMirrorQuad command, headless: mirrors the objects into the other three quadrants of plane (None = the active viewport’s construction plane, like the command; world XY when there is no view). Each object gets three history-linked copies — across the plane’s ZX plane, across its YZ plane, and across both — so the four quadrants stay symmetric and the copies follow when the original is edited. Returns the ids of the created copies (3 per object).

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
plane	Optional[PlaneLike]	optional — None = the tool default

ra.transform.move()

ra.transform.move(object_ids=None, translation=None, copy=None) -> List[str]

Translates the objects by translation mm. copy True leaves the originals and returns the ids of the copies; False moves in place and returns the same ids.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
translation	Optional[VectorLike]	optional — None = the tool default
copy	bool	optional — None = the tool default

ra.transform.move_by_normal()

ra.transform.move_by_normal(object_ids: Sequence[IdLike], surface_id: IdLike, distance=None) -> int

The ArtisanMoveByNormal command, headless: moves each object along the normal of surface_id — evaluated at the surface point closest to the object’s bounding-box center, so each object follows its own local normal — by distance mm (the command’s initial default is 1.0; negative moves against the normal). surface_id must be a surface or a single-face polysurface/extrusion, like the command’s surface pick. In-place moves: returns the number of objects moved.

Parameter	Type
object_ids	Sequence[IdLike]	required
surface_id	IdLike	required
distance	float	optional — None = the tool default

ra.transform.move_on_objects()

ra.transform.move_on_objects(object_ids: Sequence[IdLike], target_ids: Sequence[IdLike], point: PointLike) -> int

The ArtisanMoveOnObjects command, headless: same placement math as CopyOnObjects (same base mesh, same per-object frame from the mesh point and normal closest to the bounding-box center) but the objects are MOVED in place onto the single point (pulled onto the base mesh first, like the command’s cursor constraint). Returns the number of objects moved.

Parameter	Type
object_ids	Sequence[IdLike]	required
target_ids	Sequence[IdLike]	required
point	PointLike	required

ra.transform.move_random()

ra.transform.move_random(object_ids=None, distance=None) -> List[str]

The ArtisanMoveRandom command, headless: moves EACH object by distance mm along its own random unit direction (a different direction per object), to break the perfect regularity of pave stones or beads. 0 = the command’s default distance, 0.05 mm; the command accepts -1000..1000. In-place move; returns the ids moved.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
distance	float	optional — None = the tool default

ra.transform.orient_on_surface()

ra.transform.orient_on_surface(object_ids: Sequence[IdLike], surface_id: IdLike, points: Sequence[PointLike], scale=None, angle_degrees=None, normal_offset=None, alignment=None, flip=None) -> List[str]

The ArtisanOrientOnSurface command, headless: copies the objects onto surface_id (a surface/polysurface/extrusion), once per point in points (each point = one click of the command). The set is anchored by the active construction plane (world XY headless) whose origin sits at the bounding-box alignment point (“Center” default, “Top” or “Bottom” = the box’s top/bottom face center) and mapped to the surface frame at the point closest to each pick. Options as the command: scale (uniform, 0 = 1), angle_degrees (spin around the surface normal), normal_offset (mm along the normal, negative = into the surface) and flip (the command’s Flip toggle: False = the command’s default orientation, True = the other side). Returns the ids of the created copies (points x objects), in point-major order.

Parameter	Type
object_ids	Sequence[IdLike]	required
surface_id	IdLike	required
points	Sequence[PointLike]	required
scale	float	optional — None = the tool default
angle_degrees	float	optional — None = the tool default
normal_offset	float	optional — None = the tool default
alignment	str	optional — None = the tool default
flip	bool	optional — None = the tool default

ra.transform.rotate()

ra.transform.rotate(object_ids=None, angle_degrees=None, axis=None, center=None, copy=None) -> List[str]

Rotates the objects angle_degrees around axis (“X”, “Y” or “Z”, world-oriented) through center (None = the center of the common bounding box, so the selection spins in place). Positive angles are counter-clockwise looking down the axis. copy True rotates copies.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
angle_degrees	float	optional — None = the tool default
axis	str	optional — None = the tool default
center	Optional[PointLike]	optional — None = the tool default
copy	bool	optional — None = the tool default

ra.transform.scale()

ra.transform.scale(object_ids=None, factor=None, factor_y=None, factor_z=None, center=None, copy=None) -> List[str]

Scales the objects by factor about center (None = the center of the common bounding box). factorY/factorZ 0 = same as factor (uniform); given, each axis scales by its own factor (world axes). copy True scales copies.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
factor	float	optional — None = the tool default
factor_y	float	optional — None = the tool default
factor_z	float	optional — None = the tool default
center	Optional[PointLike]	optional — None = the tool default
copy	bool	optional — None = the tool default

ra.transform.scale_by_center()

ra.transform.scale_by_center(object_ids=None, factor=None) -> List[str]

The ArtisanScaleByCenter command, headless: scales the objects uniformly by factor (> 0; 1 = no change) about the center of their common bounding box, so the set grows/shrinks in place. The scale plane is the active construction plane (world XY headless) moved to that center, like the command. In place; returns the ids.

Parameter	Type
object_ids	Sequence[IdLike]	optional — None = the tool default
factor	float	optional — None = the tool default

ra.transform.scale_by_weight()

ra.transform.scale_by_weight(object_ids: Sequence[IdLike], target_grams: float, metal=None, keep_original=None) -> float

Uniformly scales the objects so they weigh exactly target_grams when cast in metal (the ArtisanScaleByWeight tool, headless). metal empty/None = the document’s primary metal; keep_original True scales a copy and leaves the original (the tool’s DeleteOriginal toggle, inverted). Objects must be closed solids/ meshes for their volume to count. Returns the scale factor that was applied (1.0 = it already weighed the target).

Parameter	Type
object_ids	Sequence[IdLike]	required
target_grams	float	required
metal	str	optional — None = the tool default
keep_original	bool	optional — None = the tool default

ra.transform.scale_to_dimensions()

ra.transform.scale_to_dimensions(object_ids: Sequence[IdLike], size_x=None, size_y=None, size_z=None, keep_aspect=None, keep_original=None) -> List[str]

The ArtisanScaleByDimensions panel, headless: scales the objects (as one set, about the center of their common world-axis bounding box) so that box measures exactly the given sizes, in mm. 0 on an axis = leave that axis alone (factor from the other axes, or 1). With keep_aspect True (the panel’s Keep Aspect toggle, on by default) exactly ONE of sizeX/sizeY/sizeZ must be given and the scale is uniform on the three axes — “make it 20 mm wide”. With keep_aspect False each given axis scales independently. An axis on which the selection is flat (zero extent) cannot be driven, same as the panel disabling that field. keep_original True scales a copy and leaves the original (the panel’s Delete Original toggle, inverted; the panel default is to delete). Returns the ids of the resulting objects: new copies when keep_original is True, the same ids (scaled in place) otherwise.

Parameter	Type
object_ids	Sequence[IdLike]	required
size_x	float	optional — None = the tool default
size_y	float	optional — None = the tool default
size_z	float	optional — None = the tool default
keep_aspect	bool	optional — None = the tool default
keep_original	bool	optional — None = the tool default

ra.transform.taper()

ra.transform.taper(object_ids: Sequence[IdLike], delta_mm: float, direction=None, mode=None, break_one=None, break_two=None, flat=None, infinite=None, rigid_ids=None, keep_original=None) -> List[str]

Tapers the objects along a bounding-box axis (the ArtisanTaper tool, headless): the section grows/shrinks linearly toward the “Top” end of the axis - tapered shanks, cone-ing a motif. delta_mm is how much the half-width changes at the far end, in mm: positive widens, negative narrows; must be non-zero. direction and the mode/break_one/break_two trio work exactly like Twist’s (defaults “ZTop”, “Uniform”, 0.5, 0.75). flat tapers only in the gumball plane’s X (one-directional squeeze); infinite extends the taper beyond the axis ends instead of clamping. Returns the new object ids.

Parameter	Type
object_ids	Sequence[IdLike]	required
delta_mm	float	required
direction	str	optional — None = the tool default
mode	str	optional — None = the tool default
break_one	float	optional — None = the tool default
break_two	float	optional — None = the tool default
flat	bool	optional — None = the tool default
infinite	bool	optional — None = the tool default
rigid_ids	Sequence[IdLike]	optional — None = the tool default
keep_original	bool	optional — None = the tool default

ra.transform.twist()

ra.transform.twist(object_ids: Sequence[IdLike], angle_degrees: float, direction=None, mode=None, break_one=None, break_two=None, rigid_ids=None, keep_original=None) -> List[str]

Twists the objects angle_degrees around a bounding-box axis (the ArtisanTwist tool, headless) - rope-like shanks, twisted wires, spiral motifs. direction is the twist axis through the bounding box: “ZTop” (default), “ZBottom”, “YTop”, “YBottom”, “XTop”, “XBottom” - the “Top” end is the one that rotates. mode limits where the twist happens along that axis: “Uniform” (default, whole length), “OneBreak” (only past break_one) or “TwoBreaks” (only between break_one and break_two). The breaks are normalized 0-1 positions on the axis; 0 = the tool defaults (0.5 and 0.75). Circles are rebuilt to 10-point degree-3 curves before twisting (same as the command), so they can actually deform. Returns the new object ids.

Parameter	Type
object_ids	Sequence[IdLike]	required
angle_degrees	float	required
direction	str	optional — None = the tool default
mode	str	optional — None = the tool default
break_one	float	optional — None = the tool default
break_two	float	optional — None = the tool default
rigid_ids	Sequence[IdLike]	optional — None = the tool default
keep_original	bool	optional — None = the tool default