user: How do I use Object Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: ll shape keys.

bpy.ops.object.shape_key_make_basis()
:   Make this shape key the new basis key, effectively applying it to the mesh. Note that this applies the shape key at its 100% value

bpy.ops.object.shape_key_mirror(*\**, *use_topology=False*)
:   Mirror the current shape key along the local X axis

    Parameters:
    :   **use_topology** (*boolean**,* *(**optional**)*) – Topology Mirror, Use topology based mirroring (for when both sides of mesh have matching, unique topology)

bpy.ops.object.shape_key_move(*\**, *type='TOP'*)
:   Move selected shape keys up/down in the list

    Parameters:
    :   **type** (enum in [`'TOP'`, `'UP'`, `'DOWN'`, `'BOTTOM'`], (optional)) –

        Type

        - `TOP`
          Top – Top of the list.
        - `UP`
          Up.
        - `DOWN`
          Down.
        - `BOTTOM`
          Bottom – Bottom of the list.

bpy.ops.object.shape_key_remove(*\**, *all=False*, *apply_mix=False*)
:   Remove shape key from the object

    Parameters:
    :   - **all** (*boolean**,* *(**optional**)*) – All, Remove all shape keys
        - **apply_mix** (*boolean**,* *(**optional**)*) – Apply Mix, Apply current mix of shape keys to the geometry before removing them

bpy.ops.object.shape_key_retime()
:   Resets the timing for absolute shape keys

bpy.ops.object.shape_key_transfer(*\**, *mode='OFFSET'*, *use_clamp=False*)
:   Copy the active shape key of another selected object to this one

    Parameters:
    :   - **mode** (enum in [`'OFFSET'`, `'RELATIVE_FACE'`, `'RELATIVE_EDGE'`], (optional)) –

          Transformation Mode, Relative shape positions to the new shape method

          - `OFFSET`
            Offset – Apply the relative positional offset.
          - `RELATIVE_FACE`
            Relative Face – Calculate relative position (using faces).
          - `RELATIVE_EDGE`
            Relative Edge – Calculate relative position (using edges).
        - **use_clamp** (*boolean**,* *(**optional**)*) – Clamp Offset, Clamp the transformation to the distance each vertex moves in the original shape

    File:
    :   [startup/bl_operators/object.py:502](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/object.py#L502)

bpy.ops.object.simulation_nodes_cache_bake(*\**, *selected=False*)
:   Bake simulations in geometry nodes modifiers

    Parameters:
    :   **selected** (*boolean**,* *(**optional**)*) – Selected, Bake cache on all selected objects

bpy.ops.object.simulation_nodes_cache_calculate_to_frame(*\**, *selected=False*)
:   Calculate simulations in geometry nodes modifiers from the start to current frame

    Parameters:
    :   **selected** (*boolean**,* *(**optional**)*) – Selected, Calculate all selected objects instead of just the active object

bpy.ops.object.simulation_nodes_cache_delete(*\**, *selected=False*)
:   Delete cached/baked simulations in geometry nodes modifiers

    Parameters:
    :   **selected** (*boolean**,* *(**optional**)*) – Selected, Delete cache on all selected objects

bpy.ops.object.skin_armature_create(*\**, *modifier=''*)
:   Create an armature that parallels the skin layout

    Parameters:
    :   **modifier** (*string**,* *(**optional**,* *never None**)*) – Modifier, Name of the modifier to edit

bpy.ops.object.skin_loose_mark_clear(*\**, *action='MARK'*)
:   Mark/clear selected vertices as loose

    Parameters:
    :   **action** (enum in [`'MARK'`, `'CLEAR'`], (optional)) –

        Action

        - `MARK`
          Mark – Mark selected vertices as loose.
        - `CLEAR`
          Clear – Set selected vertices as not loose.

bpy.ops.object.skin_radii_equalize()
:   Make skin radii of selected vertices equal on each axis

bpy.ops.object.skin_root_mark()
:   Mark selected vertices as roots

bpy.ops.object.speaker_add(*\**, *enter_editmode=False*, *align='WORLD'*, *location=(0.0, 0.0, 0.0)*, *rotation=(0.0, 0.0, 0.0)*, *scale=(0.0, 0.0, 0.0)*)
:   Add a speaker object to the scene

    Parameters:
    :   - **enter_editmode** (*boolean**,* *(**optional**)*) – Enter Edit Mode, Enter edit mode when adding this object
        - **align** (enum in [`'WORLD'`, `'VIEW'`, `'CURSOR'`], (optional)) –

          Align, The alignment of the new object

          - `WORLD`
            World – Align the new object to the world.
          - `VIEW`
            View – Align the new object to the view.
          - `CURSOR`
            3D Cursor – Use the 3D cursor orientation for the new object.
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
        - **rotation** ([`mathutils.Euler`](mathutils.html#mathutils.Euler "mathutils.Euler") rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
        - **scale** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.object.subdivision_set(*\**, *level=1*, *relative=False*, *ensure_modifier=True*)
:   Sets a Subdivision Surface level (1 to 5)

    Parameters:
    :   - **level** (*int in* *[**-100**,* *100**]**,* *(**optional**)*) – Level
        - **relative** (*boolean**,* *(**optional**)*) – Relative, Apply the subdivision surface level as an offset relative to the current level
        - **ensure_modifier** (*boolean**,* *(**optional**)*) – Ensure Modifier, Create the corresponding modifier if it does not exist

    File:
    :   [startup/bl_operators/object.py:245](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/object.py#L245)

bpy.ops.object.surfacedeform_bind(*\**, *modifier=''*)
:   Bind mesh to target in surface deform modifier

    Parameters:
    :   **modifier** (*string**,* *(**optional**,* *never None**)*) – Modifier, Name of the modifier to edit

bpy.ops.object.text_add(*\**, *radius=1.0*, *enter_editmode=False*, *align='WORLD'*, *location=(0.0, 0.0, 0.0)*, *rotation=(0.0, 0.0, 0.0)*, *scale=(0.0, 0.0, 0.0)*)
:   Add a text object to the scene

    Parameters:
    :   - **radius** (*float in* *[**0**,* *inf**]**,* *(**optional**)*) – Radius
        - **enter_editmode** (*boolean**,* *(**optional**)*) – Enter Edit Mode, Enter edit mode when adding this object
        - **align** (enum in [`'WORLD'`, `'VIEW'`, `'CURSOR'`], (optional)) –

          Align, The alignment of the new object

          - `WORLD`
            World – Align the new object to the world.
          - `VIEW`
            View – Align the new object to the view.
          - `CURSOR`
            3D Cursor – Use the 3D cursor orientation for the new object.
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
        - **rotation** ([`mathutils.Euler`](mathutils.html#mathutils.Euler "mathutils.Euler") rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
        - **scale** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.object.track_clear(*\**, *type='CLEAR'*)
:   Clear tracking constraint or flag from object

    Parameters:
    :   **type** (enum in [`'CLEAR'`, `'CLEAR_KEEP_TRANSFORM'`], (optional)) – Type

bpy.ops.object.track_set(*\**, *type='DAMPTRACK'*)
:   Make the object track another object, using various methods/constraints

    Parameters:
    :   **type** (enum in [`'DAMPTRACK'`, `'TRACKTO'`, `'LOCKTRACK'`], (optional)) – Type

bpy.ops.object.transfer_mode(*\**, *use_flash_on_transfer=True*)
:   Switches the active object and assigns the same mode to a new one under the mouse cursor, leaving the active mode in the current one

    Parameters:
    :   **use_flash_on_transfer** (*boolean**,* *(**optional**)*) – Flash On Transfer, Flash the target object when transferring the mode

bpy.ops.object.transform_apply(*\**, *location=True*, *rotation=True*, *scale=True*, *properties=True*, *isolate_users=False*)
:   Apply the object’s transformation to its data

    Parameters:
    :   - **location** (*boolean**,* *(**optional**)*) – Location
        - **rotation** (*boolean**,* *(**optional**)*) – Rotation
        - **scale** (*boolean**,* *(**optional**)*) – Scale
        - **properties** (*boolean**,* *(**optional**)*) – Apply Properties, Modify properties such as curve vertex radius, font size and bone envelope
        - **isolate_users** (*boolean**,* *(**optional**)*) – Isolate Multi User Data, Create new object-data users if needed

bpy.ops.object.transform_axis_target()
:   Interactively point cameras and lights to a location (Ctrl translates)

bpy.ops.object.transform_to_mouse(*\**, *name=''*, *session_uid=0*, *matrix=((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0))*, *drop_x=0*, *drop_y=0*)
:   Snap selected item(s) to the mouse location

    Parameters:
    :   - **name** (*string**,* *(**optional**,* *never None**)*) – Name, Object name to place (uses the active object when this and ‘session_uid’ are unset)
        - **session_uid** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Session UUID, Session UUID of the object to place (uses the active object when this and ‘name’ are unset)
        - **matrix** ([`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 items in [-inf, inf], (optional)) – Matrix
        - **drop_x** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Drop X, X-coordinate (screen space) to place the new object under
        - **drop_y** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Drop Y, Y-coordinate (screen space) to place the new object under

bpy.ops.object.transforms_to_deltas(*\**, *mode='ALL'*, *reset_values=True*)
:   Convert normal object transforms to delta transforms, any existing delta transforms will be included as well

    Parameters:
    :   - **mode** (enum in [`'ALL'`, `'LOC'`, `'ROT'`, `'SCALE'`], (optional)) –

          Mode, Which transforms to transfer

          - `ALL`
            All Transforms – Transfer location, rotation, and scale transforms.
          - `LOC`
            Location – Transfer location transforms only.
          - `ROT`
            Rotation – Transfer rotation transforms only.
          - `SCALE`
            Scale – Transfer scale transforms only.
        - **reset_values** (*boolean**,* *(**optional**)*) – Reset Values, Clear transform values after transferring to deltas

    File:
    :   [startup/bl_operators/object.py:764](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/object.py#L764)

bpy.ops.object.unlink_data()
:   Undocumented, consider [contributing](https://developer.blender.org/).

bpy.ops.object.update_shapes(*\**, *use_mirror=False*)
:   Update existing shape keys with the vertex positions of selected objects with matching names

    Parameters:
    :   **use_mirror** (*boolean**,* *(**optional**)*) – Mirror, Mirror the new shape key values

bpy.ops.object.vertex_group_add()
:   Add a new vertex group to the active object

bpy.ops.object.vertex_group_assign()
:   Assign the selected vertices to the active vertex group

bpy.ops.object.vertex_group_assign_new()
:   Assign the selected vertices to a new vertex group

bpy.ops.object.vertex_group_clean(*\**, *group_select_mode=''*, *limit=0.0*, *keep_single=False*)
:   Remove vertex group assignments which are not required

    Parameters:
    :   - **group_select_mode** (*enum in* *[**]**,* *(**optional**)*) – Subset, Define which subset of groups shall be used
        - **limit** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Limit, Remove vertices which weight is below or equal to this limit
        - **keep_single** (*boolean**,* *(**optional**)*) – Keep Single, Keep verts assigned to at least one group when cleaning

bpy.ops.object.vertex_group_copy()
:   Make a copy of the active vertex group

bpy.ops.object.vertex_group_copy_to_selected()
:   Replace vertex groups of selected objects by vertex groups of active object

bpy.ops.object.vertex_group_deselect()
:   Deselect all selected vertices assigned to the active vertex group

bpy.ops.object.vertex_group_invert(*\**, *group_select_mode=''*, *auto_assign=True*, *auto_remove=True*)
:   Invert active vertex group’s weights

    Parameters:
    :   - **group_select_mode** (*enum in* *[**]**,* *(**optional**)*) – Subset, Define which subset of groups shall be used
        - **auto_assign** (*boolean**,* *(**optional**)*) – Add Weights, Add vertices from groups that have zero weight before inverting
        - **auto_remove** (*boolean**,* *(**optional**)*) – Remove Weights, Remove vertices from groups that have zero weight after inverting

bpy.ops.object.vertex_group_levels(*\**, *group_select_mode=''*, *offset=0.0*, *gain=1.0*)
:   Add some offset and multiply with some gain the weights of the active vertex group

    Parameters:
    :   - **group_select_mode** (*enum in* *[**]**,* *(**optional**)*) – Subset, Define which subset of groups shall be used
        - **offset** (*float in* *[**-1**,* *1**]**,* *(**optional**)*) – Offset, Value to add to weights
        - **gain** (*float in* *[**0**,* *inf**]**,* *(**optional**)*) – Gain, Value to multiply weights by

bpy.ops.object.vertex_group_limit_total(*\**, *group_select_mode=''*, *limit=4*)
:   Limit deform weights associated with a vertex to a specified number by removing lowest weights

    Parameters:
    :   - **group_select_mode** (*enum in* *[**]**,* *(**optional**)*) – Subset, Define which subset of groups shall be used
        - **limit** (*int in* *[**1**,* *32**]**,* *(**optional**)*) – Limit, Maximum number of deform weights

bpy.ops.object.vertex_group_lock(*\**, *action='TOGGLE'*, *mask='ALL'*)
:   Change the lock state of all or some vertex groups of active object

    Parameters:
    :   - **action** (enum in [`'TOGGLE'`, `'LOCK'`, `'UNLOCK'`, `'INVERT'`], (optional)) –

          Action, Lock action to execute on vertex groups

          - `TOGGLE`
            Toggle – Unlock all vertex groups if there is at least one locked group, lock all in other case.
          - `LOCK`
            Lock – Lock all vertex groups.
          - `UNLOCK`
            Unlock – Unlock all vertex groups.
          - `INVERT`
            Invert – Invert the lock state of all vertex groups.
        - **mask** (enum in [`'ALL'`, `'SELECTED'`, `'UNSELECTED'`, `'INVERT_UNSELECTED'`], (optional)) –

          Mask, Apply the action based on vertex group selection

          - `ALL`
            All – Apply action to all vertex groups.
          - `SELECTED`
            Selected – Apply to selected vertex groups.
          - `UNSELECTED`
            Unselected – Apply to unselected vertex groups.
          - `INVERT_UNSELECTED`
            Invert Unselected – Apply the opposite of Lock/Unlock to unselected vertex groups.

bpy.ops.object.vertex_group_mirror(*\**, *mirror_weights=True*, *flip_group_names=True*, *all_groups=False*, *use_topology=False*)
:   Mirror vertex group, flip weights and/or names, editing only selected vertices, flipping when both sides are selected otherwise copy from unselected

    Parameters:
    :   - **mirror_weights** (*boolean**,* *(**optional**)*) – Mirror Weights, Mirror weights
        - **flip_group_names** (*boolean**,* *(**optional**)*) – Flip Group Names, Flip vertex group names
        - **all_groups** (*boolean**,* *(**optional**)*) – All Groups, Mirror all vertex groups weights
        - **use_topology** (*boolean**,* *(**optional**)*) – Topology Mirror, Use topology based mirroring (for when both sides of mesh have matching, unique topology)

bpy.ops.object.vertex_group_move(*\**, *direction='UP'*)
:   Move the active vertex group up/down in the list

    Parameters:
    :   **direction** (enum in [`'UP'`, `'DOWN'`], (optional)) – Direction, Direction to move the active vertex group towards

bpy.ops.object.vertex_group_normalize()
:   Normalize weights of the active vertex group, so that the highest ones are now 1.0

bpy.ops.object.vertex_group_normalize_all(*\**, *group_select_mode=''*, *lock_active=True*)
:   Normalize all weights of all vertex groups, so that for each vertex, the sum of all weights is 1.0

    Parameters:
    :   - **group_select_mode** (*enum in* *[**]**,* *(**optional**)*) – Subset, Define which subset of groups shall be used
        - **lock_active** (*boolean**,* *(**optional**)*) – Lock Active, Keep the values of the active group while normalizing others

bpy.ops.object.vertex_group_quantize(*\**, *group_select_mode=''*, *steps=4*)
:   Set weights to a fixed number of steps

    Parameters:
    :   - **group_select_mode** (*enum in* *[**]**,* *(**optional**)*) – Subset, Define which subset of groups shall be used
        - **steps** (*int in* *[**1**,* *1000**]**,* *(**optional**)*) – Steps, Number of steps between 0 and 1

bpy.ops.object.vertex_group_remove(*\**, *all=False*, *all_unlocked=False*)
:   Delete the active or all vertex groups from the active object

    Parameters:
    :   - **all** (*boolean**,* *(**optional**)*) – All, Remove all vertex groups
        - **all_unlocked** (*boolean**,* *(**optional**)*) – All Unlocked, Remove all unlocked vertex groups

bpy.ops.object.vertex_group_remove_from(*\**, *use_all_groups=False*, *use_all_verts=False*)
:   Remove the selected vertices from active or all vertex group(s)

    Parameters:
    :   - **use_all_groups** (*boolean**,* *(**optional**)*) – All Groups, Remove from all groups
        - **use_all_verts** (*boolean**,* *(**optional**)*) – All Vertices, Clear the active group

bpy.ops.object.vertex_group_select()
:   Select all the vertices assigned to the active vertex group

bpy.ops.object.vertex_group_set_active(*\**, *group=''*)
:   S