Operator list¶

Objectives¶

This is a copy from the file OperatorList.txt. It is also available with the menu sequence Help » Operator Cheat Sheet.

Instructions¶

Tasks:

Select the menu Help » Operator Cheat Sheet
Switch the text file and search for » mesh.primitive_ «

List of operators¶

Start searching in most browsers (Ctrl+f), more information are available in the API.

http://www.blender.org/documentation/blender_python_api_2_69_1/

# 1469 Operators

# Simplify F-Curves by removing closely spaced keyframes
bpy.ops.action.clean(threshold=0.001)
# Select keyframes by clicking on them
bpy.ops.action.clickselect(extend=False, column=False)
# Copy selected keyframes to the copy/paste buffer
bpy.ops.action.copy()
# Remove all selected keyframes
bpy.ops.action.delete()
# Make a copy of all selected keyframes
bpy.ops.action.duplicate()
# Make a copy of all selected keyframes and move them
bpy.ops.action.duplicate_move(ACTION_OT_duplicate={}, TRANSFORM_OT_transform={“mode”:’TRANSLATION’, “value”:(0, 0, 0, 0), “axis”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “release_confirm”:False})
# Set extrapolation mode for selected F-Curves
bpy.ops.action.extrapolation_type(type=’CONSTANT’)
# Set the current frame to the average frame value of selected keyframes
bpy.ops.action.frame_jump()
# Set type of handle for selected keyframes
bpy.ops.action.handle_type(type=’FREE’)
# Set interpolation mode for the F-Curve segments starting from the selected keyframes
bpy.ops.action.interpolation_type(type=’CONSTANT’)
# Insert keyframes for the specified channels
bpy.ops.action.keyframe_insert(type=’ALL’)
# Set type of keyframe for the selected keyframes
bpy.ops.action.keyframe_type(type=’KEYFRAME’)
# Move selected scene markers to the active Action as local ‘pose’ markers
bpy.ops.action.markers_make_local()
# Flip selected keyframes over the selected mirror line
bpy.ops.action.mirror(type=’CFRA’)
# Create new action
bpy.ops.action.new()
# Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame
bpy.ops.action.paste(offset=’START’, merge=’MIX’)
# Set Preview Range based on extents of selected Keyframes
bpy.ops.action.previewrange_set()
# Add keyframes on every frame between the selected keyframes
bpy.ops.action.sample()
# Toggle selection of all keyframes
bpy.ops.action.select_all_toggle(invert=False)
# Select all keyframes within the specified region
bpy.ops.action.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, axis_range=False)
# Select all keyframes on the specified frame(s)
bpy.ops.action.select_column(mode=’KEYS’)
# Select keyframes to the left or the right of the current frame
bpy.ops.action.select_leftright(mode=’CHECK’, extend=False)
# Deselect keyframes on ends of selection islands
bpy.ops.action.select_less()
# Select keyframes occurring in the same F-Curves as selected ones
bpy.ops.action.select_linked()
# Select keyframes beside already selected ones
bpy.ops.action.select_more()
# Snap selected keyframes to the times specified
bpy.ops.action.snap(type=’CFRA’)
# Reset viewable area to show full keyframe range
bpy.ops.action.view_all()
# Reset viewable area to show selected keyframes range
bpy.ops.action.view_selected()

# Interactively change the current frame number
bpy.ops.anim.change_frame(frame=0)
# Handle mouse-clicks over animation channels
bpy.ops.anim.channels_click(extend=False, children_only=False)
# Collapse (i.e. close) all selected expandable animation channels
bpy.ops.anim.channels_collapse(all=True)
# Delete all selected animation channels
bpy.ops.anim.channels_delete()
# Toggle editability of selected channels
bpy.ops.anim.channels_editable_toggle(mode=’TOGGLE’, type=’PROTECT’)
# Expand (i.e. open) all selected expandable animation channels
bpy.ops.anim.channels_expand(all=True)
# Clears ‘disabled’ tag from all F-Curves to get broken F-Curves working again
bpy.ops.anim.channels_fcurves_enable()
# Add selected F-Curves to a new group
bpy.ops.anim.channels_group(name=”New Group”)
# Rearrange selected animation channels
bpy.ops.anim.channels_move(direction=’DOWN’)
# Rename animation channel under mouse
bpy.ops.anim.channels_rename()
# Toggle selection of all animation channels
bpy.ops.anim.channels_select_all_toggle(invert=False)
# Select all animation channels within the specified region
bpy.ops.anim.channels_select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Disable specified setting on all selected animation channels
bpy.ops.anim.channels_setting_disable(mode=’DISABLE’, type=’PROTECT’)
# Enable specified setting on all selected animation channels
bpy.ops.anim.channels_setting_enable(mode=’ENABLE’, type=’PROTECT’)
# Toggle specified setting on all selected animation channels
bpy.ops.anim.channels_setting_toggle(mode=’TOGGLE’, type=’PROTECT’)
# Remove selected F-Curves from their current groups
bpy.ops.anim.channels_ungroup()
# Make only the selected animation channels visible in the Graph Editor
bpy.ops.anim.channels_visibility_set()
# Toggle visibility in Graph Editor of all selected animation channels
bpy.ops.anim.channels_visibility_toggle()
# Mark actions with no F-Curves for deletion after save & reload of file preserving “action libraries”
bpy.ops.anim.clear_useless_actions(only_unused=True)
# Copy the driver for the highlighted button
bpy.ops.anim.copy_driver_button()
# Add driver(s) for the property(s) connected represented by the highlighted button
bpy.ops.anim.driver_button_add(all=True)
# Remove the driver(s) for the property(s) connected represented by the highlighted button
bpy.ops.anim.driver_button_remove(all=True)
# Clear all keyframes on the currently active property
bpy.ops.anim.keyframe_clear_button(all=True)
# Remove all keyframe animation for selected objects
bpy.ops.anim.keyframe_clear_v3d()
# Delete keyframes on the current frame for all properties in the specified Keying Set
bpy.ops.anim.keyframe_delete(type=’DEFAULT’, confirm_success=True)
# Delete current keyframe of current UI-active property
bpy.ops.anim.keyframe_delete_button(all=True)
# Remove keyframes on current frame for selected objects
bpy.ops.anim.keyframe_delete_v3d()
# Insert keyframes on the current frame for all properties in the specified Keying Set
bpy.ops.anim.keyframe_insert(type=’DEFAULT’, confirm_success=True)
# Insert a keyframe for current UI-active property
bpy.ops.anim.keyframe_insert_button(all=True)
# Insert Keyframes for specified Keying Set, with menu of available Keying Sets if undefined
bpy.ops.anim.keyframe_insert_menu(type=’DEFAULT’, confirm_success=False, always_prompt=False)
# Select a new keying set as the active one
bpy.ops.anim.keying_set_active_set(type=’DEFAULT’)
# Add a new (empty) Keying Set to the active Scene
bpy.ops.anim.keying_set_add()
# Export Keying Set to a python script
bpy.ops.anim.keying_set_export(filepath=””, filter_folder=True, filter_text=True, filter_python=True)
# Add empty path to active Keying Set
bpy.ops.anim.keying_set_path_add()
# Remove active Path from active Keying Set
bpy.ops.anim.keying_set_path_remove()
# Remove the active Keying Set
bpy.ops.anim.keying_set_remove()
# Add current UI-active property to current keying set
bpy.ops.anim.keyingset_button_add(all=True)
# Remove current UI-active property from current keying set
bpy.ops.anim.keyingset_button_remove()
# Paste the driver in the copy/paste buffer for the highlighted button
bpy.ops.anim.paste_driver_button()
# Clear Preview Range
bpy.ops.anim.previewrange_clear()
# Interactively define frame range used for playback
bpy.ops.anim.previewrange_set(xmin=0, xmax=0, ymin=0, ymax=0)
# Update data paths from 2.56 and previous versions, modifying data paths of drivers and fcurves
bpy.ops.anim.update_data_paths()

# Align selected bones to the active bone (or to their parent)
bpy.ops.armature.align()
# Change the visible armature layers
bpy.ops.armature.armature_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Automatically renames the selected bones according to which side of the target axis they fall on
bpy.ops.armature.autoside_names(type=’XAXIS’)
# Change the layers that the selected bones belong to
bpy.ops.armature.bone_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add a new bone located at the 3D-Cursor
bpy.ops.armature.bone_primitive_add(name=”Bone”)
# Automatically fix alignment of select bones’ axes
bpy.ops.armature.calculate_roll(type=’X’, axis_flip=False, axis_only=False)
# Create a new bone going from the last selected joint to the mouse position
bpy.ops.armature.click_extrude()
# Remove selected bones from the armature
bpy.ops.armature.delete()
# Make copies of the selected bones within the same armature
bpy.ops.armature.duplicate()
# Make copies of the selected bones within the same armature and move them
bpy.ops.armature.duplicate_move(ARMATURE_OT_duplicate={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Create new bones from the selected joints
bpy.ops.armature.extrude(forked=False)
# Create new bones from the selected joints and move them
bpy.ops.armature.extrude_forked(ARMATURE_OT_extrude={“forked”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Create new bones from the selected joints and move them
bpy.ops.armature.extrude_move(ARMATURE_OT_extrude={“forked”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Add bone between selected joint(s) and/or 3D-Cursor
bpy.ops.armature.fill()
# Flips (and corrects) the axis suffixes of the names of selected bones
bpy.ops.armature.flip_names()
# Tag selected bones to not be visible in Edit Mode
bpy.ops.armature.hide(unselected=False)
# Make all armature layers visible
bpy.ops.armature.layers_show_all(all=True)
# Merge continuous chains of selected bones
bpy.ops.armature.merge(type=’WITHIN_CHAIN’)
# Remove the parent-child relationship between selected bones and their parents
bpy.ops.armature.parent_clear(type=’CLEAR’)
# Set the active bone as the parent of the selected bones
bpy.ops.armature.parent_set(type=’CONNECTED’)
# Unhide all bones that have been tagged to be hidden in Edit Mode
bpy.ops.armature.reveal()
# Toggle selection status of all bones
bpy.ops.armature.select_all(action=’TOGGLE’)
# Select immediate parent/children of selected bones
bpy.ops.armature.select_hierarchy(direction=’PARENT’, extend=False)
# Flip the selection status of bones (selected -> unselected, unselected -> selected)
bpy.ops.armature.select_inverse()
# Select bones related to selected ones by parent/child relationships
bpy.ops.armature.select_linked(extend=False)
# Select similar bones by property types
bpy.ops.armature.select_similar(type=’LENGTH’, threshold=0.1)
# Isolate selected bones into a separate armature
bpy.ops.armature.separate()
# Break selected bones into chains of smaller bones
bpy.ops.armature.subdivide(number_cuts=1)
# Change the direction that a chain of bones points in (head <-> tail swap)
bpy.ops.armature.switch_direction()

# Add a boid rule to the current boid state
bpy.ops.boid.rule_add(type=’GOAL’)
# Delete current boid rule
bpy.ops.boid.rule_del()
# Move boid rule down in the list
bpy.ops.boid.rule_move_down()
# Move boid rule up in the list
bpy.ops.boid.rule_move_up()
# Add a boid state to the particle system
bpy.ops.boid.state_add()
# Delete current boid state
bpy.ops.boid.state_del()
# Move boid state down in the list
bpy.ops.boid.state_move_down()
# Move boid state up in the list
bpy.ops.boid.state_move_up()

# Set active sculpt/paint brush from it’s number
bpy.ops.brush.active_index_set(mode=””, index=0)
# Add brush by mode type
bpy.ops.brush.add()
# Set brush shape
bpy.ops.brush.curve_preset(shape=’SMOOTH’)
# Return brush to defaults based on current tool
bpy.ops.brush.reset()
# Change brush size by a scalar
bpy.ops.brush.scale_size(scalar=1)
# Control the stencil brush
bpy.ops.brush.stencil_control(mode=’TRANSLATION’, texmode=’PRIMARY’)
# When using an image texture, adjust the stencil size to fit the image aspect ratio
bpy.ops.brush.stencil_fit_image_aspect(use_repeat=True, use_scale=True, mask=False)
# Reset the stencil transformation to the default
bpy.ops.brush.stencil_reset_transform(mask=False)
# Set the UV sculpt tool
bpy.ops.brush.uv_sculpt_tool_set(tool=’PINCH’)

# Open a directory browser, Hold Shift to open the file, Alt to browse containing directory
bpy.ops.buttons.directory_browse(directory=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Open a file browser, Hold Shift to open the file, Alt to browse containing directory
bpy.ops.buttons.file_browse(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Display button panel toolbox
bpy.ops.buttons.toolbox()

# Add a Camera Preset

bpy.ops.camera.preset_add(remove_active=False, name=””)

# Place new marker at specified location
bpy.ops.clip.add_marker(location=(0, 0))
# Place new marker at the desired (clicked) position
bpy.ops.clip.add_marker_at_click()
# Add new marker and move it on movie
bpy.ops.clip.add_marker_move(CLIP_OT_add_marker={“location”:(0, 0)}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Add new marker and slide it with mouse until mouse button release
bpy.ops.clip.add_marker_slide(CLIP_OT_add_marker={“location”:(0, 0)}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Apply scale on solution itself to make distance between selected tracks equals to desired
bpy.ops.clip.apply_solution_scale(distance=0)
# Create vertex cloud using coordinates of reconstructed tracks
bpy.ops.clip.bundles_to_mesh()
# Add a Tracking Camera Intrinsics  Preset
bpy.ops.clip.camera_preset_add(remove_active=False, name=””)
# Interactively change the current frame number
bpy.ops.clip.change_frame(frame=0)
# Clean tracks with high error values or few frames
bpy.ops.clip.clean_tracks(frames=0, error=0, action=’SELECT’)
# Clear all calculated data
bpy.ops.clip.clear_solution()
# Clear tracks after/before current position or clear the whole track
bpy.ops.clip.clear_track_path(action=’REMAINED’, clear_active=False)
# Create F-Curves for object which will copy object’s movement caused by this constraint
bpy.ops.clip.constraint_to_fcurve()
# Copy selected tracks to clipboard
bpy.ops.clip.copy_tracks()
# Delete marker for current frame from selected tracks
bpy.ops.clip.delete_marker()
# Delete movie clip proxy files from the hard drive
bpy.ops.clip.delete_proxy()
# Delete selected tracks
bpy.ops.clip.delete_track()
# Automatically detect features and place markers to track
bpy.ops.clip.detect_features(placement=’FRAME’, margin=16, min_trackability=16, min_distance=120)
# Disable/enable selected markers
bpy.ops.clip.disable_markers(action=’DISABLE’)
# Select movie tracking channel
bpy.ops.clip.dopesheet_select_channel(location=(0, 0), extend=False)
# Reset viewable area to show full keyframe range
bpy.ops.clip.dopesheet_view_all()
# Jump to special frame
bpy.ops.clip.frame_jump(position=’PATHSTART’)
# Scroll view so current frame would be centered
bpy.ops.clip.graph_center_current_frame()
# Delete selected curves
bpy.ops.clip.graph_delete_curve()
# Delete curve knots
bpy.ops.clip.graph_delete_knot()
# Disable/enable selected markers
bpy.ops.clip.graph_disable_markers(action=’DISABLE’)
# Select graph curves
bpy.ops.clip.graph_select(location=(0, 0), extend=False)
# Change selection of all markers of active track
bpy.ops.clip.graph_select_all_markers(action=’TOGGLE’)
# Select curve points using border selection
bpy.ops.clip.graph_select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# View all curves in editor
bpy.ops.clip.graph_view_all()
# Hide selected tracks
bpy.ops.clip.hide_tracks(unselected=False)
# Clear hide selected tracks
bpy.ops.clip.hide_tracks_clear()
# Join selected tracks
bpy.ops.clip.join_tracks()
# Lock/unlock selected tracks
bpy.ops.clip.lock_tracks(action=’LOCK’)
# Set the clip interaction mode
bpy.ops.clip.mode_set(mode=’TRACKING’)
# Load a sequence of frames or a movie file
bpy.ops.clip.open(directory=””, files=[], filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Paste tracks from clipboard
bpy.ops.clip.paste_tracks()
# Prefetch frames from disk for faster playback/tracking
bpy.ops.clip.prefetch()
# Toggle clip properties panel
bpy.ops.clip.properties()
# Rebuild all selected proxies and timecode indices in the background
bpy.ops.clip.rebuild_proxy()
# Refine selected markers positions by running the tracker from track’s reference to current frame
bpy.ops.clip.refine_markers(backwards=False)
# Reload clip
bpy.ops.clip.reload()
# Select tracking markers
bpy.ops.clip.select(extend=False, location=(0, 0))
# Change selection of all tracking markers
bpy.ops.clip.select_all(action=’TOGGLE’)
# Select markers using border selection
bpy.ops.clip.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select markers using circle selection
bpy.ops.clip.select_circle(x=0, y=0, radius=0, gesture_mode=0)
# Select all tracks from specified group
bpy.ops.clip.select_grouped(group=’ESTIMATED’)
# Select markers using lasso selection
bpy.ops.clip.select_lasso(path=[], deselect=False, extend=True)
# Set direction of scene axis rotating camera (or it’s parent if present) and assuming selected track lies on real axis joining it with the origin
bpy.ops.clip.set_axis(axis=’X’)
# Set optical center to center of footage
bpy.ops.clip.set_center_principal()
# Set active marker as origin by moving camera (or it’s parent if present) in 3D space
bpy.ops.clip.set_origin(use_median=False)
# Set plane based on 3 selected bundles by moving camera (or it’s parent if present) in 3D space
bpy.ops.clip.set_plane(plane=’FLOOR’)
# Set scale of scene by scaling camera (or it’s parent if present)
bpy.ops.clip.set_scale(distance=0)
# Set scene’s start and end frame to match clip’s start frame and length
bpy.ops.clip.set_scene_frames()
# Set object solution scale using distance between two selected tracks
bpy.ops.clip.set_solution_scale(distance=0)
# Set keyframe used by solver
bpy.ops.clip.set_solver_keyframe(keyframe=’KEYFRAME_A’)
# Set current movie clip as a camera background in 3D view-port (works only when a 3D view-port is visible)
bpy.ops.clip.set_viewport_background()
# Prepare scene for compositing 3D objects into this footage
bpy.ops.clip.setup_tracking_scene()
# Slide marker areas
bpy.ops.clip.slide_marker(offset=(0, 0))
# Solve camera motion from tracks
bpy.ops.clip.solve_camera()
# Add selected tracks to 2D stabilization tool
bpy.ops.clip.stabilize_2d_add()
# Remove selected track from stabilization
bpy.ops.clip.stabilize_2d_remove()
# Select track which are used for stabilization
bpy.ops.clip.stabilize_2d_select()
# Use active track to compensate rotation when doing 2D stabilization
bpy.ops.clip.stabilize_2d_set_rotation()
# Toggle clip tools panel
bpy.ops.clip.tools()
# Add a Clip Track Color Preset
bpy.ops.clip.track_color_preset_add(remove_active=False, name=””)
# Copy color to all selected tracks
bpy.ops.clip.track_copy_color()
# Track selected markers
bpy.ops.clip.track_markers(backwards=False, sequence=False)
# Copy tracking settings from active track to default settings
bpy.ops.clip.track_settings_as_default()
# Create an Empty object which will be copying movement of active track
bpy.ops.clip.track_to_empty()
# Add new object for tracking
bpy.ops.clip.tracking_object_new()
# Remove object for tracking
bpy.ops.clip.tracking_object_remove()
# Add a motion tracking settings preset
bpy.ops.clip.tracking_settings_preset_add(remove_active=False, name=””)
# View whole image with markers
bpy.ops.clip.view_all(fit_view=False)
# Use a 3D mouse device to pan/zoom the view
bpy.ops.clip.view_ndof()
# Pan the view
bpy.ops.clip.view_pan(offset=(0, 0))
# View all selected elements
bpy.ops.clip.view_selected()
# Zoom in/out the view
bpy.ops.clip.view_zoom(factor=0)
# Zoom in the view
bpy.ops.clip.view_zoom_in(location=(0, 0))
# Zoom out the view
bpy.ops.clip.view_zoom_out(location=(0, 0))
# Set the zoom ratio (based on clip size)
bpy.ops.clip.view_zoom_ratio(ratio=0)

# Add a Cloth Preset

bpy.ops.cloth.preset_add(remove_active=False, name=””)

# Evaluate the namespace up until the cursor and give a list of options or complete the name if there is only one
bpy.ops.console.autocomplete()
# Print a message when the terminal initializes
bpy.ops.console.banner()
# Clear text by type
bpy.ops.console.clear(scrollback=True, history=False)
# Clear the line and store in history
bpy.ops.console.clear_line()
# Copy selected text to clipboard
bpy.ops.console.copy()
# Copy the console contents for use in a script
bpy.ops.console.copy_as_script()
# Delete text by cursor position
bpy.ops.console.delete(type=’NEXT_CHARACTER’)
# Execute the current console line as a python expression
bpy.ops.console.execute(interactive=False)
# Append history at cursor position
bpy.ops.console.history_append(text=””, current_character=0, remove_duplicates=False)
# Cycle through history
bpy.ops.console.history_cycle(reverse=False)
# Add 4 spaces at line beginning
bpy.ops.console.indent()
# Insert text at cursor position
bpy.ops.console.insert(text=””)
# Set the current language for this console
bpy.ops.console.language(language=””)
# Move cursor position
bpy.ops.console.move(type=’LINE_BEGIN’)
# Paste text from clipboard
bpy.ops.console.paste()
# Append scrollback text by type
bpy.ops.console.scrollback_append(text=””, type=’OUTPUT’)
# Set the console selection
bpy.ops.console.select_set()
# Delete 4 spaces from line beginning
bpy.ops.console.unindent()

# Clear inverse correction for ChildOf constraint
bpy.ops.constraint.childof_clear_inverse(constraint=””, owner=’OBJECT’)
# Set inverse correction for ChildOf constraint
bpy.ops.constraint.childof_set_inverse(constraint=””, owner=’OBJECT’)
# Remove constraint from constraint stack
bpy.ops.constraint.delete()
# Add default animation for path used by constraint if it isn’t animated already
bpy.ops.constraint.followpath_path_animate(constraint=””, owner=’OBJECT’, frame_start=1, length=100)
# Reset limiting distance for Limit Distance Constraint
bpy.ops.constraint.limitdistance_reset(constraint=””, owner=’OBJECT’)
# Move constraint down in constraint stack
bpy.ops.constraint.move_down(constraint=””, owner=’OBJECT’)
# Move constraint up in constraint stack
bpy.ops.constraint.move_up(constraint=””, owner=’OBJECT’)
# Clear inverse correction for ObjectSolver constraint
bpy.ops.constraint.objectsolver_clear_inverse(constraint=””, owner=’OBJECT’)
# Set inverse correction for ObjectSolver constraint
bpy.ops.constraint.objectsolver_set_inverse(constraint=””, owner=’OBJECT’)
# Reset original length of bone for Stretch To Constraint
bpy.ops.constraint.stretchto_reset(constraint=””, owner=’OBJECT’)

# Make active spline closed/opened loop
bpy.ops.curve.cyclic_toggle(direction=’CYCLIC_U’)
# (De)select first of visible part of each NURBS
bpy.ops.curve.de_select_first()
# (De)select last of visible part of each NURBS
bpy.ops.curve.de_select_last()
# Delete selected control points or segments
bpy.ops.curve.delete(type=’SELECTED’)
# Duplicate selected control points and segments between them
bpy.ops.curve.duplicate()
# Duplicate curve and move
bpy.ops.curve.duplicate_move(CURVE_OT_duplicate={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude selected control point(s)
bpy.ops.curve.extrude(mode=’TRANSLATION’)
# Extrude curve and move result
bpy.ops.curve.extrude_move(CURVE_OT_extrude={“mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Set type of handles for selected control points
bpy.ops.curve.handle_type_set(type=’AUTOMATIC’)
# Hide (un)selected control points
bpy.ops.curve.hide(unselected=False)
# Join two curves by their selected ends
bpy.ops.curve.make_segment()
# Construct a Bezier Circle
bpy.ops.curve.primitive_bezier_circle_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Bezier Curve
bpy.ops.curve.primitive_bezier_curve_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs Circle
bpy.ops.curve.primitive_nurbs_circle_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs Curve
bpy.ops.curve.primitive_nurbs_curve_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Path
bpy.ops.curve.primitive_nurbs_path_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Set per-point radius which is used for bevel tapering
bpy.ops.curve.radius_set(radius=1)
# Show again hidden control points
bpy.ops.curve.reveal()
# (De)select all control points
bpy.ops.curve.select_all(action=’TOGGLE’)
# Reduce current selection by deselecting boundary elements
bpy.ops.curve.select_less()
# Select all control points linked to active one
bpy.ops.curve.select_linked()
# Select all control points linked to already selected ones
bpy.ops.curve.select_linked_pick(deselect=False)
# Select control points directly linked to already selected ones
bpy.ops.curve.select_more()
# Select control points following already selected ones along the curves
bpy.ops.curve.select_next()
# Deselect every other vertex
bpy.ops.curve.select_nth(nth=2)
# Select control points preceding already selected ones along the curves
bpy.ops.curve.select_previous()
# Randomly select some control points
bpy.ops.curve.select_random(percent=50, extend=False)
# Select a row of control points including active one
bpy.ops.curve.select_row()
# Separate (partly) selected curves or surfaces into a new object
bpy.ops.curve.separate()
# Set shading to flat
bpy.ops.curve.shade_flat()
# Set shading to smooth
bpy.ops.curve.shade_smooth()
# Flatten angles of selected points
bpy.ops.curve.smooth()
# Flatten radii of selected points
bpy.ops.curve.smooth_radius()
# Extrude selected boundary row around pivot point and current view axis
bpy.ops.curve.spin(center=(0, 0, 0), axis=(0, 0, 0))
# Set type of active spline
bpy.ops.curve.spline_type_set(type=’POLY’, use_handles=False)
# Set softbody goal weight for selected points
bpy.ops.curve.spline_weight_set(weight=1)
# Subdivide selected segments
bpy.ops.curve.subdivide(number_cuts=1)
# Switch direction of selected splines
bpy.ops.curve.switch_direction()
# Clear the tilt of selected control points
bpy.ops.curve.tilt_clear()
# Add a new control point (linked to only selected end-curve one, if any)
bpy.ops.curve.vertex_add(location=(0, 0, 0))

# Enable nodes on a material, world or lamp

bpy.ops.cycles.use_shading_nodes()

# Bake dynamic paint image sequence surface
bpy.ops.dpaint.bake()
# Add or remove Dynamic Paint output data layer
bpy.ops.dpaint.output_toggle(output=’A’)
# Add a new Dynamic Paint surface slot
bpy.ops.dpaint.surface_slot_add()
# Remove the selected surface slot
bpy.ops.dpaint.surface_slot_remove()
# Toggle whether given type is active or not
bpy.ops.dpaint.type_toggle(type=’CANVAS’)

# Redo previous action
bpy.ops.ed.redo()
# Undo previous action
bpy.ops.ed.undo()
# Redo specific action in history
bpy.ops.ed.undo_history(item=0)
# Add an undo state (internal use only)
bpy.ops.ed.undo_push(message=”Add an undo step function may be moved”)

# Save a BVH motion capture file from an armature

bpy.ops.export_anim.bvh(check_existing=True, filepath=””, filter_glob=”*.bvh”, global_scale=1, frame_start=0, frame_end=0, rotate_mode=’NATIVE’, root_transform_only=False)

# Export a single object as a Stanford PLY with normals, colors and texture coordinates
bpy.ops.export_mesh.ply(check_existing=True, filepath=””, filter_glob=”*.ply”, use_mesh_modifiers=True, use_normals=True, use_uv_coords=True, use_colors=True, axis_forward=’Y’, axis_up=’Z’, global_scale=1)
# Save STL triangle mesh data from the active object
bpy.ops.export_mesh.stl(check_existing=True, filepath=””, filter_glob=”*.stl”, ascii=False, use_mesh_modifiers=True, axis_forward=’Y’, axis_up=’Z’, global_scale=1)

# Export to 3DS file format (.3ds)
bpy.ops.export_scene.autodesk_3ds(check_existing=True, filepath=””, filter_glob=”*.3ds”, use_selection=False, axis_forward=’Y’, axis_up=’Z’)
# Selection to an ASCII Autodesk FBX
bpy.ops.export_scene.fbx(check_existing=True, filepath=””, filter_glob=”*.fbx”, use_selection=False, global_scale=1, axis_forward=’-Z’, axis_up=’Y’, object_types={‘EMPTY’, ‘CAMERA’, ‘LAMP’, ‘ARMATURE’, ‘MESH’}, use_mesh_modifiers=True, mesh_smooth_type=’FACE’, use_mesh_edges=False, use_armature_deform_only=False, use_anim=True, use_anim_action_all=True, use_default_take=True, use_anim_optimize=True, anim_optimize_precision=6, path_mode=’AUTO’, use_rotate_workaround=False, xna_validate=False, batch_mode=’OFF’, use_batch_own_dir=True, use_metadata=True)
# Save a Wavefront OBJ File
bpy.ops.export_scene.obj(check_existing=True, filepath=””, filter_glob=”.obj;.mtl”, use_selection=False, use_animation=False, use_mesh_modifiers=True, use_edges=True, use_smooth_groups=False, use_normals=False, use_uvs=True, use_materials=True, use_triangles=False, use_nurbs=False, use_vertex_groups=False, use_blen_objects=True, group_by_object=False, group_by_material=False, keep_vertex_order=False, axis_forward=’-Z’, axis_up=’Y’, global_scale=1, path_mode=’AUTO’)
# Export selection to Extensible 3D file (.x3d)
bpy.ops.export_scene.x3d(check_existing=True, filepath=””, filter_glob=”*.x3d”, use_selection=False, use_mesh_modifiers=True, use_triangulate=False, use_normals=False, use_compress=False, use_hierarchy=True, name_decorations=True, use_h3d=False, axis_forward=’Z’, axis_up=’Y’, global_scale=1, path_mode=’AUTO’)

# Add a bookmark for the selected/active directory
bpy.ops.file.bookmark_add()
# Toggle bookmarks display
bpy.ops.file.bookmark_toggle()
# Cancel loading of selected file
bpy.ops.file.cancel()
# Delete selected files
bpy.ops.file.delete()
# Delete selected bookmark
bpy.ops.file.delete_bookmark(index=-1)
# Enter a directory name
bpy.ops.file.directory()
# Create a new directory
bpy.ops.file.directory_new(directory=””)
# Execute selected file
bpy.ops.file.execute(need_active=False)
# Increment number in filename
bpy.ops.file.filenum(increment=1)
# Try to find missing external files
bpy.ops.file.find_missing_files(find_all=False, directory=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Toggle hide hidden dot files
bpy.ops.file.hidedot()
# Highlight selected file(s)
bpy.ops.file.highlight()
# Make all paths to external files absolute
bpy.ops.file.make_paths_absolute()
# Make all paths to external files relative to current .blend
bpy.ops.file.make_paths_relative()
# Move to next folder
bpy.ops.file.next()
# Pack all used external files into the .blend
bpy.ops.file.pack_all()
# Pack all used Blender library files into the current .blend
bpy.ops.file.pack_libraries()
# Move to parent directory
bpy.ops.file.parent()
# Move to previous folder
bpy.ops.file.previous()
# Refresh the file list
bpy.ops.file.refresh()
# Rename file or file directory
bpy.ops.file.rename()
# Report all missing external files
bpy.ops.file.report_missing_files()
# Reset Recent files
bpy.ops.file.reset_recent()
# Activate/select file
bpy.ops.file.select(extend=False, fill=False, open=True)
# Select or deselect all files
bpy.ops.file.select_all_toggle()
# Select a bookmarked directory
bpy.ops.file.select_bookmark(dir=””)
# Activate/select the file(s) contained in the border
bpy.ops.file.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Smooth scroll to make editable file visible
bpy.ops.file.smoothscroll()
# Unpack all files packed into this .blend to external ones
bpy.ops.file.unpack_all(method=’USE_LOCAL’)
# Unpack this file to an external file
bpy.ops.file.unpack_item(method=’USE_LOCAL’, id_name=””, id_type=19785)
# Unpack all used Blender library files from this .blend file
bpy.ops.file.unpack_libraries()

# Bake fluid simulation
bpy.ops.fluid.bake()
# Add a Fluid Preset
bpy.ops.fluid.preset_add(remove_active=False, name=””)

# Set font case
bpy.ops.font.case_set(case=’LOWER’)
# Toggle font case
bpy.ops.font.case_toggle()
# Change font character code
bpy.ops.font.change_character(delta=1)
# Change font spacing
bpy.ops.font.change_spacing(delta=1)
# Delete text by cursor position
bpy.ops.font.delete(type=’ALL’)
# Paste contents from file
bpy.ops.font.file_paste(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=True, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Insert placeholder text
bpy.ops.font.insert_lorem()
# Insert line break at cursor position
bpy.ops.font.line_break()
# Move cursor to position type
bpy.ops.font.move(type=’LINE_BEGIN’)
# Make selection from current cursor position to new cursor position type
bpy.ops.font.move_select(type=’LINE_BEGIN’)
# Load a new font from a file
bpy.ops.font.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=True, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Set font style
bpy.ops.font.style_set(style=’BOLD’, clear=False)
# Toggle font style
bpy.ops.font.style_toggle(style=’BOLD’)
# Copy selected text to clipboard
bpy.ops.font.text_copy()
# Cut selected text to clipboard
bpy.ops.font.text_cut()
# Insert text at cursor position
bpy.ops.font.text_insert(text=””, accent=False)
# Paste text from clipboard
bpy.ops.font.text_paste()
# Add a new text box
bpy.ops.font.textbox_add()
# Remove the textbox
bpy.ops.font.textbox_remove(index=0)
# Unlink active font data block
bpy.ops.font.unlink()

# Delete the active frame for the active Grease Pencil datablock
bpy.ops.gpencil.active_frame_delete()
# Convert the active Grease Pencil layer to a new Curve Object
bpy.ops.gpencil.convert(type=’PATH’, use_normalize_weights=True, radius_multiplier=1, use_link_strokes=True, timing_mode=’<UNKNOWN ENUM>’, frame_range=100, start_frame=1, use_realtime=False, end_frame=250, gap_duration=0, gap_randomness=0, seed=0, use_timing_data=False)
# Add new Grease Pencil datablock
bpy.ops.gpencil.data_add()
# Unlink active Grease Pencil datablock
bpy.ops.gpencil.data_unlink()
# Make annotations on the active data
bpy.ops.gpencil.draw(mode=’DRAW’, stroke=[])
# Add new Grease Pencil layer for the active Grease Pencil datablock
bpy.ops.gpencil.layer_add()

# Bake selected F-Curves to a set of sampled points defining a similar curve
bpy.ops.graph.bake()
# Simplify F-Curves by removing closely spaced keyframes
bpy.ops.graph.clean(threshold=0.001)
# Insert new keyframe at the cursor position for the active F-Curve
bpy.ops.graph.click_insert(frame=1, value=1)
# Select keyframes by clicking on them
bpy.ops.graph.clickselect(extend=False, column=False, curves=False)
# Copy selected keyframes to the copy/paste buffer
bpy.ops.graph.copy()
# Interactively set the current frame number and value cursor
bpy.ops.graph.cursor_set(frame=0, value=0)
# Remove all selected keyframes
bpy.ops.graph.delete()
# Make a copy of all selected keyframes
bpy.ops.graph.duplicate(mode=’TRANSLATION’)
# Make a copy of all selected keyframes and move them
bpy.ops.graph.duplicate_move(GRAPH_OT_duplicate={“mode”:’TRANSLATION’}, TRANSFORM_OT_transform={“mode”:’TRANSLATION’, “value”:(0, 0, 0, 0), “axis”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “release_confirm”:False})
# Fix large jumps and flips in the selected Euler Rotation F-Curves arising from rotation values being clipped when baking physics
bpy.ops.graph.euler_filter()
# Set extrapolation mode for selected F-Curves
bpy.ops.graph.extrapolation_type(type=’CONSTANT’)
# Add F-Modifiers to the selected F-Curves
bpy.ops.graph.fmodifier_add(type=’NULL’, only_active=True)
# Copy the F-Modifier(s) of the active F-Curve
bpy.ops.graph.fmodifier_copy()
# Add copied F-Modifiers to the selected F-Curves
bpy.ops.graph.fmodifier_paste()
# Place the cursor on the midpoint of selected keyframes
bpy.ops.graph.frame_jump()
# Clear F-Curve snapshots (Ghosts) for active Graph Editor
bpy.ops.graph.ghost_curves_clear()
# Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor
bpy.ops.graph.ghost_curves_create()
# Set type of handle for selected keyframes
bpy.ops.graph.handle_type(type=’FREE’)
# Set interpolation mode for the F-Curve segments starting from the selected keyframes
bpy.ops.graph.interpolation_type(type=’CONSTANT’)
# Insert keyframes for the specified channels
bpy.ops.graph.keyframe_insert(type=’ALL’)
# Flip selected keyframes over the selected mirror line
bpy.ops.graph.mirror(type=’CFRA’)
# Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame
bpy.ops.graph.paste(offset=’START’, merge=’MIX’)
# Automatically set Preview Range based on range of keyframes
bpy.ops.graph.previewrange_set()
# Toggle display properties panel
bpy.ops.graph.properties()
# Add keyframes on every frame between the selected keyframes
bpy.ops.graph.sample()
# Toggle selection of all keyframes
bpy.ops.graph.select_all_toggle(invert=False)
# Select all keyframes within the specified region
bpy.ops.graph.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, axis_range=False, include_handles=False)
# Select all keyframes on the specified frame(s)
bpy.ops.graph.select_column(mode=’KEYS’)
# Select keyframes to the left or the right of the current frame
bpy.ops.graph.select_leftright(mode=’CHECK’, extend=False)
# Deselect keyframes on ends of selection islands
bpy.ops.graph.select_less()
# Select keyframes occurring in the same F-Curves as selected ones
bpy.ops.graph.select_linked()
# Select keyframes beside already selected ones
bpy.ops.graph.select_more()
# Apply weighted moving means to make selected F-Curves less bumpy
bpy.ops.graph.smooth()
# Snap selected keyframes to the chosen times/values
bpy.ops.graph.snap(type=’CFRA’)
# Bakes a sound wave to selected F-Curves
bpy.ops.graph.sound_bake(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, low=0, high=100000, attack=0.005, release=0.2, threshold=0, use_accumulate=False, use_additive=False, use_square=False, sthreshold=0.1)
# Reset viewable area to show full keyframe range
bpy.ops.graph.view_all(include_handles=True)
# Reset viewable area to show selected keyframe range
bpy.ops.graph.view_selected(include_handles=True)

# Create an object group from selected objects
bpy.ops.group.create(name=”Group”)
# Add the object to an object group that contains the active object
bpy.ops.group.objects_add_active(group=’<UNKNOWN ENUM>’)
# Remove selected objects from all groups or a selected group
bpy.ops.group.objects_remove(group=’<UNKNOWN ENUM>’)
# Remove the object from an object group that contains the active object
bpy.ops.group.objects_remove_active()
# Remove selected objects from all groups or a selected group
bpy.ops.group.objects_remove_all()

# Set black point or white point for curves
bpy.ops.image.curves_point_set(point=’BLACK_POINT’)
# Cycle through all non-void render slots
bpy.ops.image.cycle_render_slot(reverse=False)
# Edit image in an external application
bpy.ops.image.external_edit(filepath=””)
# Invert image’s channels
bpy.ops.image.invert(invert_r=False, invert_g=False, invert_b=False, invert_a=False)
# Set image’s user’s length to the one of this video
bpy.ops.image.match_movie_length()
# Create a new image
bpy.ops.image.new(name=”Untitled”, width=1024, height=1024, color=(0, 0, 0, 1), alpha=True, generated_type=’BLANK’, float=False)
# Open image
bpy.ops.image.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Pack an image as embedded data into the .blend file
bpy.ops.image.pack(as_png=False)
# Project edited image back onto the object
bpy.ops.image.project_apply()
# Edit a snapshot of the view-port in an external image editor
bpy.ops.image.project_edit()
# Toggle display properties panel
bpy.ops.image.properties()
# Reload current image from disk
bpy.ops.image.reload()
# Replace current image by another one from disk
bpy.ops.image.replace(filepath=””, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Use mouse to sample a color in current image
bpy.ops.image.sample()
# Sample a line and show it in Scope panels
bpy.ops.image.sample_line(xstart=0, xend=0, ystart=0, yend=0, cursor=1)
# Save the image with current name and settings
bpy.ops.image.save()
# Save the image with another name and/or settings
bpy.ops.image.save_as(save_as_render=False, copy=False, filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Save all modified textures
bpy.ops.image.save_dirty()
# Save a sequence of images
bpy.ops.image.save_sequence()
# Toggle display scopes panel
bpy.ops.image.scopes()
# Save an image packed in the .blend file to disk
bpy.ops.image.unpack(method=’USE_LOCAL’, id=””)
# View the entire image
bpy.ops.image.view_all()
# Use a 3D mouse device to pan/zoom the view
bpy.ops.image.view_ndof()
# Pan the view
bpy.ops.image.view_pan(offset=(0, 0))
# View all selected UVs
bpy.ops.image.view_selected()
# Zoom in/out the image
bpy.ops.image.view_zoom(factor=0)
# Zoom in the image (centered around 2D cursor)
bpy.ops.image.view_zoom_in(location=(0, 0))
# Zoom out the image (centered around 2D cursor)
bpy.ops.image.view_zoom_out(location=(0, 0))
# Set zoom ratio of the view
bpy.ops.image.view_zoom_ratio(ratio=0)

# Load a BVH motion capture file

bpy.ops.import_anim.bvh(filepath=””, filter_glob=”*.bvh”, target=’ARMATURE’, global_scale=1, frame_start=1, use_fps_scale=False, use_cyclic=False, rotate_mode=’NATIVE’, axis_forward=’-Z’, axis_up=’Y’)

# Load a SVG file

bpy.ops.import_curve.svg(filepath=””, filter_glob=”*.svg”)

# Load a PLY geometry file
bpy.ops.import_mesh.ply(filepath=””, files=[], directory=””, filter_glob=”*.ply”)
# Load STL triangle mesh data
bpy.ops.import_mesh.stl(filepath=””, filter_glob=”*.stl”, files=[], directory=””)

# Import from 3DS file format (.3ds)
bpy.ops.import_scene.autodesk_3ds(filepath=””, filter_glob=”*.3ds”, constrain_size=10, use_image_search=True, use_apply_transform=True, axis_forward=’Y’, axis_up=’Z’)
# Load a Wavefront OBJ File
bpy.ops.import_scene.obj(filepath=””, filter_glob=”.obj;.mtl”, use_ngons=True, use_edges=True, use_smooth_groups=True, use_split_objects=True, use_split_groups=True, use_groups_as_vgroups=False, use_image_search=True, split_mode=’ON’, global_clamp_size=0, axis_forward=’-Z’, axis_up=’Y’)
# Import an X3D or VRML2 file
bpy.ops.import_scene.x3d(filepath=””, filter_glob=”.x3d;.wrl”, axis_forward=’Z’, axis_up=’Y’)

# Copy selected reports to Clipboard
bpy.ops.info.report_copy()
# Delete selected reports
bpy.ops.info.report_delete()
# Replay selected reports
bpy.ops.info.report_replay()
# Update the display of reports in Blender UI (internal use)
bpy.ops.info.reports_display_update()
# Select or deselect all reports
bpy.ops.info.select_all_toggle()
# Toggle border selection
bpy.ops.info.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select reports by index
bpy.ops.info.select_pick(report_index=0)

# Add a Sky & Atmosphere Preset

bpy.ops.lamp.sunsky_preset_add(remove_active=False, name=””)

# Mirror all control points without inverting the lattice deform
bpy.ops.lattice.flip(axis=’U’)
# Set UVW control points a uniform distance apart
bpy.ops.lattice.make_regular()
# Change selection of all UVW control points
bpy.ops.lattice.select_all(action=’TOGGLE’)
# Select vertices without a group
bpy.ops.lattice.select_ungrouped(extend=False)

# Add an actuator to the active object
bpy.ops.logic.actuator_add(type=’MOTION’, name=””, object=””)
# Move Actuator
bpy.ops.logic.actuator_move(actuator=””, object=””, direction=’UP’)
# Remove an actuator from the active object
bpy.ops.logic.actuator_remove(actuator=””, object=””)
# Add a controller to the active object
bpy.ops.logic.controller_add(type=’LOGIC_AND’, name=””, object=””)
# Move Controller
bpy.ops.logic.controller_move(controller=””, object=””, direction=’UP’)
# Remove a controller from the active object
bpy.ops.logic.controller_remove(controller=””, object=””)
# Remove logic brick connections
bpy.ops.logic.links_cut(path=[], cursor=9)
# Toggle display properties panel
bpy.ops.logic.properties()
# Add a sensor to the active object
bpy.ops.logic.sensor_add(type=’ALWAYS’, name=””, object=””)
# Move Sensor
bpy.ops.logic.sensor_move(sensor=””, object=””, direction=’UP’)
# Remove a sensor from the active object
bpy.ops.logic.sensor_remove(sensor=””, object=””)
# Convert old texface settings into material. It may create new materials if needed
bpy.ops.logic.texface_convert()
# Resize view so you can see all logic bricks
bpy.ops.logic.view_all()

# Add a new time marker
bpy.ops.marker.add()
# Bind the active camera to selected markers(s)
bpy.ops.marker.camera_bind()
# Delete selected time marker(s)
bpy.ops.marker.delete()
# Duplicate selected time marker(s)
bpy.ops.marker.duplicate(frames=0)
# Copy selected markers to another scene
bpy.ops.marker.make_links_scene(scene=’Scene’)
# Move selected time marker(s)
bpy.ops.marker.move(frames=0)
# Rename first selected time marker
bpy.ops.marker.rename(name=”RenamedMarker”)
# Select time marker(s)
bpy.ops.marker.select(extend=False, camera=False)
# Change selection of all time markers
bpy.ops.marker.select_all(action=’TOGGLE’)
# Select all time markers using border selection
bpy.ops.marker.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)

# Add vertex to feather
bpy.ops.mask.add_feather_vertex(location=(0, 0))
# Add new vertex to feather and slide it
bpy.ops.mask.add_feather_vertex_slide(MASK_OT_add_feather_vertex={“location”:(0, 0)}, MASK_OT_slide_point={“slide_feather”:False})
# Add vertex to active spline
bpy.ops.mask.add_vertex(location=(0, 0))
# Add new vertex and slide it
bpy.ops.mask.add_vertex_slide(MASK_OT_add_vertex={“location”:(0, 0)}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Toggle cyclic for selected splines
bpy.ops.mask.cyclic_toggle()
# Delete selected control points or splines
bpy.ops.mask.delete()
# Reset the feather weight to zero
bpy.ops.mask.feather_weight_clear()
# Set type of handles for selected control points
bpy.ops.mask.handle_type_set(type=’AUTO’)
# Reveal the layer by setting the hide flag
bpy.ops.mask.hide_view_clear()
# Hide the layer by setting the hide flag
bpy.ops.mask.hide_view_set(unselected=False)
# Move the active layer up/down in the list
bpy.ops.mask.layer_move(direction=’UP’)
# Add new mask layer for masking
bpy.ops.mask.layer_new(name=””)
# Remove mask layer
bpy.ops.mask.layer_remove()
# Create new mask
bpy.ops.mask.new(name=””)
# Re-calculate the direction of selected handles
bpy.ops.mask.normals_make_consistent()
# Clear the mask’s parenting
bpy.ops.mask.parent_clear()
# Set the mask’s parenting
bpy.ops.mask.parent_set()
# Select spline points
bpy.ops.mask.select(extend=False, deselect=False, toggle=False, location=(0, 0))
# Change selection of all curve points
bpy.ops.mask.select_all(action=’TOGGLE’)
# Select markers using border selection
bpy.ops.mask.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select markers using circle selection
bpy.ops.mask.select_circle(x=0, y=0, radius=0, gesture_mode=0)
# Select markers using lasso selection
bpy.ops.mask.select_lasso(path=[], deselect=False, extend=True)
# Select all vertices linked to the active mesh
bpy.ops.mask.select_linked()
# (De)select all points linked to the curve under the mouse cursor
bpy.ops.mask.select_linked_pick(deselect=False)
#
bpy.ops.mask.shape_key_clear()
# Reset feather weights on all selected points animation values
bpy.ops.mask.shape_key_feather_reset()
#
bpy.ops.mask.shape_key_insert()
# Recalculate animation data on selected points for frames selected in the dopesheet
bpy.ops.mask.shape_key_rekey(location=True, feather=True)
# Slide control points
bpy.ops.mask.slide_point(slide_feather=False)
# Switch direction of selected splines
bpy.ops.mask.switch_direction()

# Copy the material settings and nodes
bpy.ops.material.copy()
# Add a new material
bpy.ops.material.new()
# Paste the material settings and nodes
bpy.ops.material.paste()
# Add a Subsurface Scattering Preset
bpy.ops.material.sss_preset_add(remove_active=False, name=””)

# Delete selected metaelement(s)
bpy.ops.mball.delete_metaelems()
# Duplicate selected metaelement(s)
bpy.ops.mball.duplicate_metaelems(mode=’TRANSLATION’)
# Hide (un)selected metaelement(s)
bpy.ops.mball.hide_metaelems(unselected=False)
# Reveal all hidden metaelements
bpy.ops.mball.reveal_metaelems()
# Change selection of all meta elements
bpy.ops.mball.select_all(action=’TOGGLE’)
# Randomly select metaelements
bpy.ops.mball.select_random_metaelems(percent=0.5)

# Rearrange some faces to try to get less degenerated geometry
bpy.ops.mesh.beautify_fill()
# Edge Bevel
bpy.ops.mesh.bevel(offset=0, segments=1, vertex_only=False)
# Blend in shape from a shape key
bpy.ops.mesh.blend_from_shape(shape=’<UNKNOWN ENUM>’, blend=1, add=True)
# Make faces between two or more edge loops
bpy.ops.mesh.bridge_edge_loops(type=’SINGLE’, use_merge=False, merge_factor=0.5, number_cuts=0, interpolation=’PATH’, smoothness=1, profile_shape_factor=0, profile_shape=’SMOOTH’)
# Flip direction of vertex colors inside faces
bpy.ops.mesh.colors_reverse()
# Rotate vertex colors inside faces
bpy.ops.mesh.colors_rotate(use_ccw=False)
# Enclose selected vertices in a convex polyhedron
bpy.ops.mesh.convex_hull(delete_unused=True, use_existing_faces=True, make_holes=False, join_triangles=True, limit=0.698132, uvs=False, vcols=False, sharp=False, materials=False)
# Clear vertex sculpt masking data from the mesh
bpy.ops.mesh.customdata_clear_mask()
# Clear vertex skin layer
bpy.ops.mesh.customdata_clear_skin()
# Delete selected vertices, edges or faces
bpy.ops.mesh.delete(type=’VERT’)
# Delete an edge loop by merging the faces on each side
bpy.ops.mesh.delete_edgeloop(use_face_split=True)
# Dissolve geometry
bpy.ops.mesh.dissolve_edges(use_verts=False, use_face_split=False)
# Dissolve geometry
bpy.ops.mesh.dissolve_faces(use_verts=False)
# Dissolve selected edges and verts, limited by the angle of surrounding geometry
bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665, use_dissolve_boundaries=False, delimit=set())
# Dissolve geometry
bpy.ops.mesh.dissolve_verts(use_face_split=False)
# Assign Image to active UV Map, or create an UV Map
bpy.ops.mesh.drop_named_image(name=”Image”, filepath=”Path”)
# Duplicate and extrude selected vertices, edges or faces towards the mouse cursor
bpy.ops.mesh.dupli_extrude_cursor(rotate_source=True)
# Duplicate selected vertices, edges or faces
bpy.ops.mesh.duplicate(mode=1)
# Duplicate mesh and move
bpy.ops.mesh.duplicate_move(MESH_OT_duplicate={“mode”:1}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Collapse selected edges
bpy.ops.mesh.edge_collapse()
# Add an edge or face to selected
bpy.ops.mesh.edge_face_add()
# Rotate selected edge or adjoining faces
bpy.ops.mesh.edge_rotate(use_ccw=False)
# Split selected edges so that each neighbor face gets its own copy
bpy.ops.mesh.edge_split()
# Select an edge ring
bpy.ops.mesh.edgering_select(extend=False, deselect=False, toggle=False, ring=True)
# Select all sharp-enough edges
bpy.ops.mesh.edges_select_sharp(sharpness=0.523599)
# Extrude individual edges only
bpy.ops.mesh.extrude_edges_indiv(mirror=False)
# Extrude edges and move result
bpy.ops.mesh.extrude_edges_move(MESH_OT_extrude_edges_indiv={“mirror”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude individual faces only
bpy.ops.mesh.extrude_faces_indiv(mirror=False)
# Extrude faces and move result
bpy.ops.mesh.extrude_faces_move(MESH_OT_extrude_faces_indiv={“mirror”:False}, TRANSFORM_OT_shrink_fatten={“value”:0, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “release_confirm”:False})
# Extrude region of faces
bpy.ops.mesh.extrude_region(mirror=False)
# Extrude region and move result
bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region={“mirror”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude selected vertices, edges or faces repeatedly
bpy.ops.mesh.extrude_repeat(offset=2, steps=10)
# Extrude vertices and move result
bpy.ops.mesh.extrude_vertices_move(MESH_OT_extrude_verts_indiv={“mirror”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude individual vertices only
bpy.ops.mesh.extrude_verts_indiv(mirror=False)
# Copy mirror UV coordinates on the X axis based on a mirrored mesh
bpy.ops.mesh.faces_mirror_uv(direction=’POSITIVE’, precision=3)
# Select linked faces by angle
bpy.ops.mesh.faces_select_linked_flat(sharpness=0.0174533)
# Display faces flat
bpy.ops.mesh.faces_shade_flat()
# Display faces smooth (using vertex normals)
bpy.ops.mesh.faces_shade_smooth()
# Fill a selected edge loop with faces
bpy.ops.mesh.fill(use_beauty=True)
# Fill grid from two loops
bpy.ops.mesh.fill_grid()
# Flip the direction of selected faces’ normals (and of their vertices)
bpy.ops.mesh.flip_normals()
# Hide (un)selected vertices, edges or faces
bpy.ops.mesh.hide(unselected=False)
# Inset new faces into selected faces
bpy.ops.mesh.inset(use_boundary=True, use_even_offset=True, use_relative_offset=False, thickness=0.01, depth=0, use_outset=False, use_select_inset=True, use_individual=False, use_interpolate=True)
# Use other objects outlines & boundaries to project knife cuts
bpy.ops.mesh.knife_project()
# Cut new topology
bpy.ops.mesh.knife_tool(use_occlude_geometry=True, only_selected=False)
# Select a loop of connected edges by connection type
bpy.ops.mesh.loop_multi_select(ring=False)
# Select a loop of connected edges
bpy.ops.mesh.loop_select(extend=False, deselect=False, toggle=False, ring=False)
# Select region of faces inside of a selected loop of edges
bpy.ops.mesh.loop_to_region(select_bigger=False)
# Add a new loop between existing loops
bpy.ops.mesh.loopcut(number_cuts=1, smoothness=0, falloff=’ROOT’, edge_index=-1, mesh_select_mode_init=(False, False, False))
# Cut mesh loop and slide it
bpy.ops.mesh.loopcut_slide(MESH_OT_loopcut={“number_cuts”:1, “smoothness”:0, “falloff”:’ROOT’, “edge_index”:-1, “mesh_select_mode_init”:(False, False, False)}, TRANSFORM_OT_edge_slide={“value”:0, “mirror”:False, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “correct_uv”:False, “release_confirm”:False})
# (Un)mark selected edges as Freestyle feature edges
bpy.ops.mesh.mark_freestyle_edge(clear=False)
# (Un)mark selected faces for exclusion from Freestyle feature edge detection
bpy.ops.mesh.mark_freestyle_face(clear=False)
# (Un)mark selected edges as a seam
bpy.ops.mesh.mark_seam(clear=False)
# (Un)mark selected edges as sharp
bpy.ops.mesh.mark_sharp(clear=False)
# Merge selected vertices
bpy.ops.mesh.merge(type=’CENTER’, uvs=False)
# Remove navmesh data from this mesh
bpy.ops.mesh.navmesh_clear()
# Add a new index and assign it to selected faces
bpy.ops.mesh.navmesh_face_add()
# Copy the index from the active face
bpy.ops.mesh.navmesh_face_copy()
# Create navigation mesh for selected objects
bpy.ops.mesh.navmesh_make()
# Assign a new index to every face
bpy.ops.mesh.navmesh_reset()
# Use vertex coordinate as texture coordinate
bpy.ops.mesh.noise(factor=0.1)
# Make face and vertex normals point either outside or inside the mesh
bpy.ops.mesh.normals_make_consistent(inside=False)
# Split a face into a fan
bpy.ops.mesh.poke(offset=0, use_relative_offset=False, center_mode=’MEAN_WEIGHTED’)
# Construct a circle mesh
bpy.ops.mesh.primitive_circle_add(vertices=32, radius=1, fill_type=’NOTHING’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a conic mesh
bpy.ops.mesh.primitive_cone_add(vertices=32, radius1=1, radius2=0, depth=2, end_fill_type=’NGON’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a cube mesh
bpy.ops.mesh.primitive_cube_add(radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a cylinder mesh
bpy.ops.mesh.primitive_cylinder_add(vertices=32, radius=1, depth=2, end_fill_type=’NGON’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a grid mesh
bpy.ops.mesh.primitive_grid_add(x_subdivisions=10, y_subdivisions=10, radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct an Icosphere mesh
bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=2, size=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Suzanne mesh
bpy.ops.mesh.primitive_monkey_add(radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a filled planar mesh with 4 vertices
bpy.ops.mesh.primitive_plane_add(radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add a torus mesh
bpy.ops.mesh.primitive_torus_add(rotation=(0, 0, 0), view_align=False, location=(0, 0, 0), major_radius=1, minor_radius=0.25, major_segments=48, minor_segments=12, use_abso=False, abso_major_rad=1, abso_minor_rad=0.5)
# Construct a UV sphere mesh
bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=16, size=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Triangulate selected faces
bpy.ops.mesh.quads_convert_to_tris(use_beauty=True)
# Select boundary edges around the selected faces
bpy.ops.mesh.region_to_loop()
# Remove duplicate vertices
bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=False)
# Reveal all hidden vertices, edges and faces
bpy.ops.mesh.reveal()
# Disconnect vertex or edges from connected geometry
bpy.ops.mesh.rip(mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, release_confirm=False, use_fill=False)
# Rip polygons and move the result
bpy.ops.mesh.rip_move(MESH_OT_rip={“mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “release_confirm”:False, “use_fill”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Rip-fill polygons and move the result
bpy.ops.mesh.rip_move_fill(MESH_OT_rip={“mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “release_confirm”:False, “use_fill”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude selected vertices in screw-shaped rotation around the cursor in indicated viewport
bpy.ops.mesh.screw(steps=9, turns=1, center=(0, 0, 0), axis=(0, 0, 0))
# (De)select all vertices, edges or faces
bpy.ops.mesh.select_all(action=’TOGGLE’)
# Select all data in the mesh on a single axis
bpy.ops.mesh.select_axis(mode=’POSITIVE’, axis=’X_AXIS’)
# Select vertices or faces by the number of polygon sides
bpy.ops.mesh.select_face_by_sides(number=4, type=’EQUAL’, extend=True)
# Select faces where all edges have more than 2 face users
bpy.ops.mesh.select_interior_faces()
# Deselect vertices, edges or faces at the boundary of each selection region
bpy.ops.mesh.select_less()
# Select all vertices linked to the active mesh
bpy.ops.mesh.select_linked(limit=False)
# (De)select all vertices linked to the edge under the mouse cursor
bpy.ops.mesh.select_linked_pick(deselect=False, limit=False)
# Select loose geometry based on the selection mode
bpy.ops.mesh.select_loose(extend=False)
# Select mesh items at mirrored locations
bpy.ops.mesh.select_mirror(extend=False)
# Change selection mode
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type=’VERT’, action=’TOGGLE’)
# Select more vertices, edges or faces connected to initial selection
bpy.ops.mesh.select_more()
# Select next edge loop adjacent to a selected loop
bpy.ops.mesh.select_next_loop()
# Select all non-manifold vertices or edges
bpy.ops.mesh.select_non_manifold(extend=True)
# Deselect every Nth element starting from the active vertex, edge or face
bpy.ops.mesh.select_nth(nth=2, offset=0)
# Randomly select vertices
bpy.ops.mesh.select_random(percent=50, extend=False)
# Select similar vertices, edges or faces by property types
bpy.ops.mesh.select_similar(type=’NORMAL’, compare=’EQUAL’, threshold=0)
# Select vertices without a group
bpy.ops.mesh.select_ungrouped(extend=False)
# Separate selected geometry into a new mesh
bpy.ops.mesh.separate(type=’SELECTED’)
# Apply selected vertex locations to all other shape keys
bpy.ops.mesh.shape_propagate_to_all()
# Select shortest path between two selections
bpy.ops.mesh.shortest_path_pick(extend=False)
# Selected vertex path between two vertices
bpy.ops.mesh.shortest_path_select(use_length=True)
# Create a solid skin by extruding, compensating for sharp angles
bpy.ops.mesh.solidify(thickness=0.01)
# The order of selected vertices/edges/faces is modified, based on a given method
bpy.ops.mesh.sort_elements(type=’VIEW_ZAXIS’, elements=set(), reverse=False, seed=0)
# Extrude selected vertices in a circle around the cursor in indicated viewport
bpy.ops.mesh.spin(steps=9, dupli=False, angle=1.5708, center=(0, 0, 0), axis=(0, 0, 0))
# Split off selected geometry from connected unselected geometry
bpy.ops.mesh.split()
# Subdivide selected edges
bpy.ops.mesh.subdivide(number_cuts=1, smoothness=0, quadtri=False, quadcorner=’STRAIGHT_CUT’, fractal=0, fractal_along_normal=0, seed=0)
#
bpy.ops.mesh.subdivide_edgering(number_cuts=10, interpolation=’PATH’, smoothness=1, profile_shape_factor=0, profile_shape=’SMOOTH’)
# Enforce symmetry (both form and topological) across an axis
bpy.ops.mesh.symmetrize(direction=’NEGATIVE_X’)
# Snap vertex pairs to their mirrored locations
bpy.ops.mesh.symmetry_snap(direction=’NEGATIVE_X’, threshold=0.05, factor=0.5, use_center=True)
# Join triangles into quads
bpy.ops.mesh.tris_convert_to_quads(limit=0.698132, uvs=False, vcols=False, sharp=False, materials=False)
# UnSubdivide selected edges & faces
bpy.ops.mesh.unsubdivide(iterations=2)
# Add UV Map
bpy.ops.mesh.uv_texture_add()
# Remove UV Map
bpy.ops.mesh.uv_texture_remove()
# Flip direction of UV coordinates inside faces
bpy.ops.mesh.uvs_reverse()
# Rotate UV coordinates inside faces
bpy.ops.mesh.uvs_rotate(use_ccw=False)
# Connect 2 vertices of a face by an edge, splitting the face in two
bpy.ops.mesh.vert_connect()
# Add vertex color layer
bpy.ops.mesh.vertex_color_add()
# Remove vertex color layer
bpy.ops.mesh.vertex_color_remove()
# Flatten angles of selected vertices
bpy.ops.mesh.vertices_smooth(repeat=1, xaxis=True, yaxis=True, zaxis=True)
# Laplacian smooth of selected vertices
bpy.ops.mesh.vertices_smooth_laplacian(repeat=1, lambda_factor=5e-05, lambda_border=5e-05, use_x=True, use_y=True, use_z=True, preserve_volume=True)
# Inset new faces into selected faces
bpy.ops.mesh.wireframe(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_crease=False, thickness=0.01, use_replace=True)

# Synchronize the length of the referenced Action with the length used in the strip
bpy.ops.nla.action_sync_length(active=True)
# Add an Action-Clip strip (i.e. an NLA Strip referencing an Action) to the active track
bpy.ops.nla.actionclip_add(action=’<UNKNOWN ENUM>’)
# Apply scaling of selected strips to their referenced Actions
bpy.ops.nla.apply_scale()
# Bake object/pose loc/scale/rotation animation to a new action
bpy.ops.nla.bake(frame_start=1, frame_end=250, step=1, only_selected=True, clear_constraints=False, clear_parents=False, bake_types={‘POSE’})
# Handle clicks to select NLA channels
bpy.ops.nla.channels_click(extend=False)
# Reset scaling of selected strips
bpy.ops.nla.clear_scale()
# Handle clicks to select NLA Strips
bpy.ops.nla.click_select(extend=False)
# Delete selected strips
bpy.ops.nla.delete()
# Duplicate selected NLA-Strips, adding the new strips in new tracks above the originals
bpy.ops.nla.duplicate(mode=’TRANSLATION’)
# Add a F-Modifier of the specified type to the selected NLA-Strips
bpy.ops.nla.fmodifier_add(type=’NULL’, only_active=False)
# Copy the F-Modifier(s) of the active NLA-Strip
bpy.ops.nla.fmodifier_copy()
# Add copied F-Modifiers to the selected NLA-Strips
bpy.ops.nla.fmodifier_paste()
# Add new meta-strips incorporating the selected strips
bpy.ops.nla.meta_add()
# Separate out the strips held by the selected meta-strips
bpy.ops.nla.meta_remove()
# Move selected strips down a track if there’s room
bpy.ops.nla.move_down()
# Move selected strips up a track if there’s room
bpy.ops.nla.move_up()
# Mute or un-mute selected strips
bpy.ops.nla.mute_toggle()
# Toggle display properties panel
bpy.ops.nla.properties()
# Select or deselect all NLA-Strips
bpy.ops.nla.select_all_toggle(invert=False)
# Use box selection to grab NLA-Strips
bpy.ops.nla.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, axis_range=False)
# Select strips to the left or the right of the current frame
bpy.ops.nla.select_leftright(mode=’CHECK’, extend=False)
# Make selected objects appear in NLA Editor by adding Animation Data
bpy.ops.nla.selected_objects_add()
# Move start of strips to specified time
bpy.ops.nla.snap(type=’CFRA’)
# Add a strip for controlling when speaker plays its sound clip
bpy.ops.nla.soundclip_add()
# Split selected strips at their midpoints
bpy.ops.nla.split()
# Swap order of selected strips within tracks
bpy.ops.nla.swap()
# Add NLA-Tracks above/after the selected tracks
bpy.ops.nla.tracks_add(above_selected=False)
# Delete selected NLA-Tracks and the strips they contain
bpy.ops.nla.tracks_delete()
# Add a transition strip between two adjacent selected strips
bpy.ops.nla.transition_add()
# Enter tweaking mode for the action referenced by the active strip
bpy.ops.nla.tweakmode_enter()
# Exit tweaking mode for the action referenced by the active strip
bpy.ops.nla.tweakmode_exit()
# Reset viewable area to show full strips range
bpy.ops.nla.view_all()
# Reset viewable area to show selected strips range
bpy.ops.nla.view_selected()

# Add a node to the active tree and link to an existing socket
bpy.ops.node.add_and_link_node(use_transform=False, settings=[], type=””, link_socket_index=0)
# Add a file node to the current node editor
bpy.ops.node.add_file(filepath=””, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, name=”Image”)
# Add a node to the active tree
bpy.ops.node.add_node(use_transform=False, settings=[], type=””)
# Add a reroute node
bpy.ops.node.add_reroute(path=[], cursor=6)
# Add a node to the active tree
bpy.ops.node.add_search(use_transform=False, settings=[], type=””, node_item=’<UNKNOWN ENUM>’)
# Attach active node to a frame
bpy.ops.node.attach()
# Move Node backdrop
bpy.ops.node.backimage_move()
# Use mouse to sample background image
bpy.ops.node.backimage_sample()
# Zoom in/out the background image
bpy.ops.node.backimage_zoom(factor=1.2)
# Copies selected nodes to the clipboard
bpy.ops.node.clipboard_copy()
# Pastes nodes from the clipboard to the active node tree
bpy.ops.node.clipboard_paste()
# Toggle collapsed nodes and hide unused sockets
bpy.ops.node.collapse_hide_unused_toggle()
# Delete selected nodes
bpy.ops.node.delete()
# Delete nodes; will reconnect nodes as if deletion was muted
bpy.ops.node.delete_reconnect()
# Detach selected nodes from parents
bpy.ops.node.detach()
# Detach nodes, move and attach to frame
bpy.ops.node.detach_translate_attach(NODE_OT_detach={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, NODE_OT_attach={})
# Duplicate selected nodes
bpy.ops.node.duplicate(keep_inputs=False)
# Duplicate selected nodes and move them
bpy.ops.node.duplicate_move(NODE_OT_duplicate={“keep_inputs”:False}, NODE_OT_translate_attach={“TRANSFORM_OT_translate”:{“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, “NODE_OT_attach”:{}})
# Duplicate selected nodes keeping input links and move them
bpy.ops.node.duplicate_move_keep_inputs(NODE_OT_duplicate={“keep_inputs”:False}, NODE_OT_translate_attach={“TRANSFORM_OT_translate”:{“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, “NODE_OT_attach”:{}})
# Search for named node and allow to select and activate it
bpy.ops.node.find_node(prev=False)
# Edit node group
bpy.ops.node.group_edit(exit=False)
# Insert selected nodes into a node group
bpy.ops.node.group_insert()
# Make group from selected nodes
bpy.ops.node.group_make()
# Separate selected nodes from the node group
bpy.ops.node.group_separate(type=’COPY’)
# Ungroup selected nodes
bpy.ops.node.group_ungroup()
# Toggle unused node socket display
bpy.ops.node.hide_socket_toggle()
# Toggle hiding of selected nodes
bpy.ops.node.hide_toggle()
# Attach selected nodes to a new common frame
bpy.ops.node.join()
# Use the mouse to create a link between two nodes
bpy.ops.node.link(detach=False)
# Makes a link between selected output in input sockets
bpy.ops.node.link_make(replace=False)
# Link to viewer node
bpy.ops.node.link_viewer()
# Use the mouse to cut (remove) some links
bpy.ops.node.links_cut(path=[], cursor=9)
# Remove all links to selected nodes, and try to connect neighbor nodes together
bpy.ops.node.links_detach()
# Move a node to detach links
bpy.ops.node.move_detach_links(NODE_OT_links_detach={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Move a node to detach links
bpy.ops.node.move_detach_links_release(NODE_OT_links_detach={}, NODE_OT_translate_attach={“TRANSFORM_OT_translate”:{“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, “NODE_OT_attach”:{}})
# Toggle muting of the nodes
bpy.ops.node.mute_toggle()
# Create a new node tree
bpy.ops.node.new_node_tree(type=’CompositorNodeTree’, name=”NodeTree”)
# Add a Node Color Preset
bpy.ops.node.node_color_preset_add(remove_active=False, name=””)
# Copy color to all selected nodes
bpy.ops.node.node_copy_color()
# Toggle option buttons display for selected nodes
bpy.ops.node.options_toggle()
# Add a new input to a file output node
bpy.ops.node.output_file_add_socket(file_path=”Image”)
# Move the active input of a file output node up or down the list
bpy.ops.node.output_file_move_active_socket(direction=’DOWN’)
# Remove active input from a file output node
bpy.ops.node.output_file_remove_active_socket()
# Detach selected nodes
bpy.ops.node.parent_clear()
# Attach selected nodes
bpy.ops.node.parent_set()
# Toggle preview display for selected nodes
bpy.ops.node.preview_toggle()
# Toggles the properties panel display
bpy.ops.node.properties()
# Read all render layers of current scene, in full sample
bpy.ops.node.read_fullsamplelayers()
# Read all render layers of all used scenes
bpy.ops.node.read_renderlayers()
# Render current scene, when input node’s layer has been changed
bpy.ops.node.render_changed()
# Resize a node
bpy.ops.node.resize()
# Select the node under the cursor
bpy.ops.node.select(mouse_x=0, mouse_y=0, extend=False)
# (De)select all nodes
bpy.ops.node.select_all(action=’TOGGLE’)
# Use box selection to select nodes
bpy.ops.node.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, tweak=False)
# Select nodes using lasso selection
bpy.ops.node.select_lasso(path=[], deselect=False, extend=True)
# Select node and link it to a viewer node
bpy.ops.node.select_link_viewer(NODE_OT_select={“mouse_x”:0, “mouse_y”:0, “extend”:False}, NODE_OT_link_viewer={})
# Select nodes linked from the selected ones
bpy.ops.node.select_linked_from()
# Select nodes linked to the selected ones
bpy.ops.node.select_linked_to()
# Select all the nodes of the same type
bpy.ops.node.select_same_type()
# Activate and view same node type, step by step
bpy.ops.node.select_same_type_step(prev=False)
# Update shader script node with new sockets and options from the script
bpy.ops.node.shader_script_update()
# Sort the nodes and show the cyclic dependencies between the nodes
bpy.ops.node.show_cyclic_dependencies()
# Toggles tool shelf display
bpy.ops.node.toolbar()
# Move nodes and attach to frame
bpy.ops.node.translate_attach(TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, NODE_OT_attach={})
# Go to parent node tree
bpy.ops.node.tree_path_parent()
# Add an input or output socket to the current node tree
bpy.ops.node.tree_socket_add(in_out=’IN’)
# Move a socket up or down in the current node tree’s sockets stack
bpy.ops.node.tree_socket_move(direction=’UP’)
# Remove an input or output socket to the current node tree
bpy.ops.node.tree_socket_remove()
# Resize view so you can see all nodes
bpy.ops.node.view_all()
# Resize view so you can see selected nodes
bpy.ops.node.view_selected()
# Set the boundaries for viewer operations
bpy.ops.node.viewer_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)

# Add an object to the scene
bpy.ops.object.add(type=’EMPTY’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add named object
bpy.ops.object.add_named(linked=False, name=”Cube”)
# Align Objects
bpy.ops.object.align(bb_quality=True, align_mode=’OPT_2’, relative_to=’OPT_4’, align_axis=set())
# Convert object animation for normal transforms to delta transforms
bpy.ops.object.anim_transforms_to_deltas()
# Add an armature object to the scene
bpy.ops.object.armature_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Bake image textures of selected objects
bpy.ops.object.bake_image()
# Add a camera object to the scene
bpy.ops.object.camera_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add a constraint to the active object
bpy.ops.object.constraint_add(type=’<UNKNOWN ENUM>’)
# Add a constraint to the active object, with target (where applicable) set to the selected Objects/Bones
bpy.ops.object.constraint_add_with_targets(type=’<UNKNOWN ENUM>’)
# Clear all the constraints for the active Object only
bpy.ops.object.constraints_clear()
# Copy constraints to other selected objects
bpy.ops.object.constraints_copy()
# Convert selected objects to another type
bpy.ops.object.convert(target=’MESH’, keep_original=False)
# Delete selected objects
bpy.ops.object.delete(use_global=False)
# Add an empty image type to scene with data
bpy.ops.object.drop_named_image(filepath=””, name=””, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
#
bpy.ops.object.drop_named_material(name=”Material”)
# Set offset used for DupliGroup based on cursor position
bpy.ops.object.dupli_offset_from_cursor(group=0)
# Duplicate selected objects
bpy.ops.object.duplicate(linked=False, mode=’TRANSLATION’)
# Duplicate selected objects and move them
bpy.ops.object.duplicate_move(OBJECT_OT_duplicate={“linked”:False, “mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Duplicate selected objects and move them
bpy.ops.object.duplicate_move_linked(OBJECT_OT_duplicate={“linked”:False, “mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Make dupli objects attached to this object real
bpy.ops.object.duplicates_make_real(use_base_parent=False, use_hierarchy=False)
# Toggle object’s editmode
bpy.ops.object.editmode_toggle()
# Add an empty object with a physics effector to the scene
bpy.ops.object.effector_add(type=’FORCE’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add an empty object to the scene
bpy.ops.object.empty_add(type=’PLAIN_AXES’, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Refresh data in the Explode modifier
bpy.ops.object.explode_refresh(modifier=””)
# Toggle object’s force field
bpy.ops.object.forcefield_toggle()
# Copy game physics properties to other selected objects
bpy.ops.object.game_physics_copy()
# Remove all game properties from all selected objects
bpy.ops.object.game_property_clear()
# Copy/merge/replace a game property from active object to all selected objects
bpy.ops.object.game_property_copy(operation=’COPY’, property=’<UNKNOWN ENUM>’)
# Create a new property available to the game engine
bpy.ops.object.game_property_new(type=’FLOAT’, name=””)
# Remove game property
bpy.ops.object.game_property_remove(index=0)
# Add an object to a new group
bpy.ops.object.group_add()
# Add a dupligroup instance
bpy.ops.object.group_instance_add(name=”Group”, group=’<UNKNOWN ENUM>’, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add an object to an existing group
bpy.ops.object.group_link(group=’<UNKNOWN ENUM>’)
# Remove the active object from this group
bpy.ops.object.group_remove()
# Reveal the render object by setting the hide render flag
bpy.ops.object.hide_render_clear()
# Reveal all render objects by setting the hide render flag
bpy.ops.object.hide_render_clear_all()
# Hide the render object by setting the hide render flag
bpy.ops.object.hide_render_set(unselected=False)
# Reveal the object by setting the hide flag
bpy.ops.object.hide_view_clear()
# Hide the object by setting the hide flag
bpy.ops.object.hide_view_set(unselected=False)
# Hook selected vertices to the first selected Object
bpy.ops.object.hook_add_newob()
# Hook selected vertices to the first selected Object
bpy.ops.object.hook_add_selob(use_bone=False)
# Assign the selected vertices to a hook
bpy.ops.object.hook_assign(modifier=’<UNKNOWN ENUM>’)
# Set hook center to cursor position
bpy.ops.object.hook_recenter(modifier=’<UNKNOWN ENUM>’)
# Remove a hook from the active object
bpy.ops.object.hook_remove(modifier=’<UNKNOWN ENUM>’)
# Recalculate and clear offset transformation
bpy.ops.object.hook_reset(modifier=’<UNKNOWN ENUM>’)
# Select affected vertices on mesh
bpy.ops.object.hook_select(modifier=’<UNKNOWN ENUM>’)
# Hide unselected render objects of same type as active by setting the hide render flag
bpy.ops.object.isolate_type_render()
# Join selected objects into active object
bpy.ops.object.join()
# Merge selected objects to shapes of active object
bpy.ops.object.join_shapes()
# Transfer UV Layouts from active to selected objects (needs matching geometry)
bpy.ops.object.join_uvs()
# Add a lamp object to the scene
bpy.ops.object.lamp_add(type=’POINT’, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Clear the object’s location
bpy.ops.object.location_clear()
# Copy logic bricks to other selected objects
bpy.ops.object.logic_bricks_copy()
# Make linked objects into dupli-faces
bpy.ops.object.make_dupli_face()
# Make links from the active object to other selected objects
bpy.ops.object.make_links_data(type=’OBDATA’)
# Link selection to another scene
bpy.ops.object.make_links_scene(scene=’Scene’)
# Make library linked datablocks local to this file
bpy.ops.object.make_local(type=’SELECT_OBJECT’)
# Make linked data local to each object
bpy.ops.object.make_single_user(type=’SELECTED_OBJECTS’, object=False, obdata=False, material=False, texture=False, animation=False)
# Add a new material slot
bpy.ops.object.material_slot_add()
# Assign active material slot to selection
bpy.ops.object.material_slot_assign()
# Copies materials to other selected objects
bpy.ops.object.material_slot_copy()
# Deselect by active material slot
bpy.ops.object.material_slot_deselect()
# Remove the selected material slot
bpy.ops.object.material_slot_remove()
# Select by active material slot
bpy.ops.object.material_slot_select()
# Bind mesh to cage in mesh deform modifier
bpy.ops.object.meshdeform_bind(modifier=””)
# Add an metaball object to the scene
bpy.ops.object.metaball_add(type=’BALL’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Sets the object interaction mode
bpy.ops.object.mode_set(mode=’OBJECT’, toggle=False)
# Add a modifier to the active object
bpy.ops.object.modifier_add(type=’SUBSURF’)
# Apply modifier and remove from the stack
bpy.ops.object.modifier_apply(apply_as=’DATA’, modifier=””)
# Convert particles to a mesh object
bpy.ops.object.modifier_convert(modifier=””)
# Duplicate modifier at the same position in the stack
bpy.ops.object.modifier_copy(modifier=””)
# Move modifier down in the stack
bpy.ops.object.modifier_move_down(modifier=””)
# Move modifier up in the stack
bpy.ops.object.modifier_move_up(modifier=””)
# Remove a modifier from the active object
bpy.ops.object.modifier_remove(modifier=””)
# Move the object to different layers
bpy.ops.object.move_to_layer(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Modify the base mesh to conform to the displaced mesh
bpy.ops.object.multires_base_apply(modifier=””)
# Pack displacements from an external file
bpy.ops.object.multires_external_pack()
# Save displacements to an external file
bpy.ops.object.multires_external_save(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=True, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, modifier=””)
# Deletes the higher resolution mesh, potential loss of detail
bpy.ops.object.multires_higher_levels_delete(modifier=””)
# Copy vertex coordinates from other object
bpy.ops.object.multires_reshape(modifier=””)
# Add a new level of subdivision
bpy.ops.object.multires_subdivide(modifier=””)
# Bake an image sequence of ocean data
bpy.ops.object.ocean_bake(modifier=””, free=False)
# Clear the object’s origin
bpy.ops.object.origin_clear()
# Set the object’s origin, by either moving the data, or set to center of data, or use 3D cursor
bpy.ops.object.origin_set(type=’GEOMETRY_ORIGIN’, center=’MEDIAN’)
# Clear the object’s parenting
bpy.ops.object.parent_clear(type=’CLEAR’)
# Set the object’s parenting without setting the inverse parent correction
bpy.ops.object.parent_no_inverse_set()
# Set the object’s parenting
bpy.ops.object.parent_set(type=’OBJECT’, xmirror=False, keep_transform=False)
# Add a particle system
bpy.ops.object.particle_system_add()
# Remove the selected particle system
bpy.ops.object.particle_system_remove()
# Calculate motion paths for the selected objects
bpy.ops.object.paths_calculate(start_frame=1, end_frame=250)
# Clear path caches for selected objects
bpy.ops.object.paths_clear()
# Recalculate paths for selected objects
bpy.ops.object.paths_update()
# Enable or disable posing/selecting bones
bpy.ops.object.posemode_toggle()
# Add empty object to become local replacement data of a library-linked object
bpy.ops.object.proxy_make(object=’DEFAULT’)
#
bpy.ops.object.quick_explode(style=’EXPLODE’, amount=100, frame_duration=50, frame_start=1, frame_end=10, velocity=1, fade=True)
#
bpy.ops.object.quick_fluid(style=’BASIC’, initial_velocity=(0, 0, 0), show_flows=False, start_baking=False)
#
bpy.ops.object.quick_fur(density=’MEDIUM’, view_percentage=10, length=0.1)
#
bpy.ops.object.quick_smoke(style=’STREAM’, show_flows=False)
# Randomize objects loc/rot/scale
bpy.ops.object.randomize_transform(random_seed=0, use_delta=False, use_loc=True, loc=(0, 0, 0), use_rot=True, rot=(0, 0, 0), use_scale=True, scale_even=False, scale=(1, 1, 1))
# Clear the object’s rotation
bpy.ops.object.rotation_clear()
# Clear the object’s scale
bpy.ops.object.scale_clear()
# Change selection of all visible objects in scene
bpy.ops.object.select_all(action=’TOGGLE’)
# Select all visible objects on a layer
bpy.ops.object.select_by_layer(match=’EXACT’, extend=False, layers=1)
# Select all visible objects that are of a type
bpy.ops.object.select_by_type(extend=False, type=’MESH’)
# Select the active camera
bpy.ops.object.select_camera(extend=False)
# Select all visible objects grouped by various properties
bpy.ops.object.select_grouped(extend=False, type=’CHILDREN_RECURSIVE’)
# Select object relative to the active object’s position in the hierarchy
bpy.ops.object.select_hierarchy(direction=’PARENT’, extend=False)
# Select all visible objects that are linked
bpy.ops.object.select_linked(extend=False, type=’OBDATA’)
# Select the Mirror objects of the selected object eg. L.sword -> R.sword
bpy.ops.object.select_mirror(extend=False)
# Select objects matching a naming pattern
bpy.ops.object.select_pattern(pattern=”*”, case_sensitive=False, extend=True)
# Set select on random visible objects
bpy.ops.object.select_random(percent=50, extend=False)
# Select object in the same group
bpy.ops.object.select_same_group(group=””)
# Render and display faces uniform, using Face Normals
bpy.ops.object.shade_flat()
# Render and display faces smooth, using interpolated Vertex Normals
bpy.ops.object.shade_smooth()
# Add shape key to the object
bpy.ops.object.shape_key_add(from_mix=True)
# Clear weights for all shape keys
bpy.ops.object.shape_key_clear()
# Mirror the current shape key along the local X axis
bpy.ops.object.shape_key_mirror(use_topology=False)
# Move the active shape key up/down in the list
bpy.ops.object.shape_key_move(type=’UP’)
# Remove shape key from the object
bpy.ops.object.shape_key_remove(all=False)
# Resets the timing for absolute shape keys
bpy.ops.object.shape_key_retime()
# Copy another selected objects active shape to this one by applying the relative offsets
bpy.ops.object.shape_key_transfer(mode=’OFFSET’, use_clamp=False)
# Create an armature that parallels the skin layout
bpy.ops.object.skin_armature_create(modifier=””)
# Mark/clear selected vertices as loose
bpy.ops.object.skin_loose_mark_clear(action=’MARK’)
# Make skin radii of selected vertices equal on each axis
bpy.ops.object.skin_radii_equalize()
# Mark selected vertices as roots
bpy.ops.object.skin_root_mark()
# Clear the object’s slow parent
bpy.ops.object.slow_parent_clear()
# Set the object’s slow parent
bpy.ops.object.slow_parent_set()
# Add a speaker object to the scene
bpy.ops.object.speaker_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Sets a Subdivision Surface Level (1-5)
bpy.ops.object.subdivision_set(level=1, relative=False)
# Add a text object to the scene
bpy.ops.object.text_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Clear tracking constraint or flag from object
bpy.ops.object.track_clear(type=’CLEAR’)
# Make the object track another object, either by constraint or old way or locked track
bpy.ops.object.track_set(type=’DAMPTRACK’)
# Apply the object’s transformation to its data
bpy.ops.object.transform_apply(location=False, rotation=False, scale=False)
# Add a new vertex group to the active object
bpy.ops.object.vertex_group_add()
# Assign the selected vertices to the active vertex group
bpy.ops.object.vertex_group_assign()
# Assign the selected vertices to a new vertex group
bpy.ops.object.vertex_group_assign_new()
# Blend selected vertex weights with unselected for the active group
bpy.ops.object.vertex_group_blend(factor=1)
# Remove Vertex Group assignments which aren’t required
bpy.ops.object.vertex_group_clean(group_select_mode=’ACTIVE’, limit=0, keep_single=False)
# Make a copy of the active vertex group
bpy.ops.object.vertex_group_copy()
# Copy Vertex Groups to all users of the same Geometry data
bpy.ops.object.vertex_group_copy_to_linked()
# Copy Vertex Groups to other selected objects with matching indices
bpy.ops.object.vertex_group_copy_to_selected()
# Deselect all selected vertices assigned to the active vertex group
bpy.ops.object.vertex_group_deselect()
# Modify the position of selected vertices by changing only their respective groups’ weights (this tool may be slow for many vertices)
bpy.ops.object.vertex_group_fix(dist=0, strength=1, accuracy=1)
# Invert active vertex group’s weights
bpy.ops.object.vertex_group_invert(group_select_mode=’ACTIVE’, auto_assign=True, auto_remove=True)
# Add some offset and multiply with some gain the weights of the active vertex group
bpy.ops.object.vertex_group_levels(group_select_mode=’ACTIVE’, offset=0, gain=1)
# Limit deform weights associated with a vertex to a specified number by removing lowest weights
bpy.ops.object.vertex_group_limit_total(group_select_mode=’ALL’, limit=4)
# Change the lock state of all vertex groups of active object
bpy.ops.object.vertex_group_lock(action=’TOGGLE’)
# Mirror all vertex groups, flip weights and/or names, editing only selected vertices, flipping when both sides are selected otherwise copy from unselected
bpy.ops.object.vertex_group_mirror(mirror_weights=True, flip_group_names=True, all_groups=False, use_topology=False)
# Move the active vertex group up/down in the list
bpy.ops.object.vertex_group_move(direction=’UP’)
# Normalize weights of the active vertex group, so that the highest ones are now 1.0
bpy.ops.object.vertex_group_normalize()
# Normalize all weights of all vertex groups, so that for each vertex, the sum of all weights is 1.0
bpy.ops.object.vertex_group_normalize_all(lock_active=True)
# Delete the active vertex group
bpy.ops.object.vertex_group_remove(all=False)
# Remove the selected vertices from active or all vertex group(s)
bpy.ops.object.vertex_group_remove_from(use_all_groups=False, use_all_verts=False)
# Select all the vertices assigned to the active vertex group
bpy.ops.object.vertex_group_select()
# Set the active vertex group
bpy.ops.object.vertex_group_set_active(group=’<UNKNOWN ENUM>’)
# Sorts vertex groups alphabetically
bpy.ops.object.vertex_group_sort()
# Transfer weight paint to active from selected mesh
bpy.ops.object.vertex_group_transfer_weight(WT_vertex_group_mode=’WT_REPLACE_ACTIVE_VERTEX_GROUP’, WT_method=’WT_BY_NEAREST_FACE’, WT_replace_mode=’WT_REPLACE_ALL_WEIGHTS’)
# Parent selected objects to the selected vertices
bpy.ops.object.vertex_parent_set()
# Copy weights from Active to selected
bpy.ops.object.vertex_weight_copy()
# Delete this weight from the vertex (disabled if vertex Group is locked)
bpy.ops.object.vertex_weight_delete(weight_group=-1)
# Normalize Active Vert Weights
bpy.ops.object.vertex_weight_normalize_active_vertex()
# Copy this group’s weight to other selected verts (disabled if vertex Group is locked)
bpy.ops.object.vertex_weight_paste(weight_group=-1)
# Set as active Vertex Group
bpy.ops.object.vertex_weight_set_active(weight_group=-1)
# Apply the object’s visual transformation to its data
bpy.ops.object.visual_transform_apply()

# Change the active action used
bpy.ops.outliner.action_set(action=’<UNKNOWN ENUM>’)
#
bpy.ops.outliner.animdata_operation(type=’SET_ACT’)
#
bpy.ops.outliner.data_operation(type=’SELECT’)
# Add drivers to selected items
bpy.ops.outliner.drivers_add_selected()
# Delete drivers assigned to selected items
bpy.ops.outliner.drivers_delete_selected()
# Expand/Collapse all items
bpy.ops.outliner.expanded_toggle()
#
bpy.ops.outliner.group_operation(type=’UNLINK’)
#
bpy.ops.outliner.id_operation(type=’UNLINK’)
# Handle mouse clicks to activate/select items
bpy.ops.outliner.item_activate(extend=True, recursive=False)
# Toggle whether item under cursor is enabled or closed
bpy.ops.outliner.item_openclose(all=True)
# Rename item under cursor
bpy.ops.outliner.item_rename()
# Add selected items (blue-gray rows) to active Keying Set
bpy.ops.outliner.keyingset_add_selected()
# Remove selected items (blue-gray rows) from active Keying Set
bpy.ops.outliner.keyingset_remove_selected()
# Drag material to object in Outliner
bpy.ops.outliner.material_drop(object=”Object”, material=”Material”)
#
bpy.ops.outliner.object_operation(type=’SELECT’)
# Context menu for item operations
bpy.ops.outliner.operation()
# Drag to clear parent in Outliner
bpy.ops.outliner.parent_clear(dragged_obj=”Object”, type=’CLEAR’)
# Drag to parent in Outliner
bpy.ops.outliner.parent_drop(child=”Object”, parent=”Object”, type=’OBJECT’)
# Toggle the renderability of selected items
bpy.ops.outliner.renderability_toggle()
# Drag object to scene in Outliner
bpy.ops.outliner.scene_drop(object=”Object”, scene=”Scene”)
# Scroll page up or down
bpy.ops.outliner.scroll_page(up=False)
# Use box selection to select tree elements
bpy.ops.outliner.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Toggle the selectability
bpy.ops.outliner.selectability_toggle()
# Toggle the Outliner selection of items
bpy.ops.outliner.selected_toggle()
# Adjust the view so that the active Object is shown centered
bpy.ops.outliner.show_active()
# Open all object entries and close all others
bpy.ops.outliner.show_hierarchy()
# Expand/collapse all entries by one level
bpy.ops.outliner.show_one_level(open=True)
# Toggle the visibility of selected items
bpy.ops.outliner.visibility_toggle()

# Select a paint mode’s brush by tool type
bpy.ops.paint.brush_select(paint_mode=’ACTIVE’, sculpt_tool=’BLOB’, vertex_paint_tool=’MIX’, weight_paint_tool=’MIX’, texture_paint_tool=’DRAW’, toggle=False, create_missing=False)
# Change selection for all faces
bpy.ops.paint.face_select_all(action=’TOGGLE’)
# Hide selected faces
bpy.ops.paint.face_select_hide(unselected=False)
# Select linked faces
bpy.ops.paint.face_select_linked()
# Select linked faces
bpy.ops.paint.face_select_linked_pick(extend=False)
# Reveal hidden faces
bpy.ops.paint.face_select_reveal(unselected=False)
# Move the clone source image
bpy.ops.paint.grab_clone(delta=(0, 0))
# Hide/show some vertices
bpy.ops.paint.hide_show(action=’HIDE’, area=’INSIDE’, xmin=0, xmax=0, ymin=0, ymax=0)
# Make an image from the current 3D view for re-projection
bpy.ops.paint.image_from_view(filepath=””)
# Paint a stroke into the image
bpy.ops.paint.image_paint(mode=’NORMAL’, stroke=[])
# Fill the whole mask with a given value, or invert its values
bpy.ops.paint.mask_flood_fill(mode=’VALUE’, value=0)
# Project an edited render from the active camera back onto the object
bpy.ops.paint.project_image(image=’Render Result’)
# Use the mouse to sample a color in the image
bpy.ops.paint.sample_color(location=(0, 0))
# Toggle texture paint mode in 3D view
bpy.ops.paint.texture_paint_toggle()
# Change selection for all vertices
bpy.ops.paint.vert_select_all(action=’TOGGLE’)
# Select vertices without a group
bpy.ops.paint.vert_select_ungrouped(extend=False)
#
bpy.ops.paint.vertex_color_dirt(blur_strength=1, blur_iterations=1, clean_angle=3.14159, dirt_angle=0, dirt_only=False)
# Fill the active vertex color layer with the current paint color
bpy.ops.paint.vertex_color_set()
# Smooth colors across vertices
bpy.ops.paint.vertex_color_smooth()
# Paint a stroke in the active vertex color layer
bpy.ops.paint.vertex_paint(stroke=[])
# Toggle the vertex paint mode in 3D view
bpy.ops.paint.vertex_paint_toggle()
# Set the weights of the groups matching the attached armature’s selected bones, using the distance between the vertices and the bones
bpy.ops.paint.weight_from_bones(type=’AUTOMATIC’)
# Sample a line and show it in Scope panels
bpy.ops.paint.weight_gradient(type=’LINEAR’, xstart=0, xend=0, ystart=0, yend=0, cursor=1)
# Paint a stroke in the current vertex group’s weights
bpy.ops.paint.weight_paint(stroke=[])
# Toggle weight paint mode in 3D view
bpy.ops.paint.weight_paint_toggle()
# Use the mouse to sample a weight in the 3D view
bpy.ops.paint.weight_sample()
# Select one of the vertex groups available under current mouse position
bpy.ops.paint.weight_sample_group(group=’<UNKNOWN ENUM>’)
# Fill the active vertex group with the current paint weight
bpy.ops.paint.weight_set()

# Apply a stroke of brush to the particles
bpy.ops.particle.brush_edit(stroke=[])
# Connect hair to the emitter mesh
bpy.ops.particle.connect_hair(all=False)
# Delete selected particles or keys
bpy.ops.particle.delete(type=’PARTICLE’)
# Disconnect hair from the emitter mesh
bpy.ops.particle.disconnect_hair(all=False)
# Duplicate the current dupliobject
bpy.ops.particle.dupliob_copy()
# Move dupli object down in the list
bpy.ops.particle.dupliob_move_down()
# Move dupli object up in the list
bpy.ops.particle.dupliob_move_up()
# Remove the selected dupliobject
bpy.ops.particle.dupliob_remove()
# Undo all edition performed on the particle system
bpy.ops.particle.edited_clear()
# Hide selected particles
bpy.ops.particle.hide(unselected=False)
# Duplicate and mirror the selected particles along the local X axis
bpy.ops.particle.mirror()
# Add new particle settings
bpy.ops.particle.new()
# Add a new particle target
bpy.ops.particle.new_target()
# Toggle particle edit mode
bpy.ops.particle.particle_edit_toggle()
# Change the number of keys of selected particles (root and tip keys included)
bpy.ops.particle.rekey(keys_number=2)
# Remove selected particles close enough of others
bpy.ops.particle.remove_doubles(threshold=0.0002)
# Show hidden particles
bpy.ops.particle.reveal()
# (De)select all particles’ keys
bpy.ops.particle.select_all(action=’TOGGLE’)
# Deselect boundary selected keys of each particle
bpy.ops.particle.select_less()
# Select nearest particle from mouse pointer
bpy.ops.particle.select_linked(deselect=False, location=(0, 0))
# Select keys linked to boundary selected keys of each particle
bpy.ops.particle.select_more()
# Select roots of all visible particles
bpy.ops.particle.select_roots(action=’SELECT’)
# Select tips of all visible particles
bpy.ops.particle.select_tips(action=’SELECT’)
# Subdivide selected particles segments (adds keys)
bpy.ops.particle.subdivide()
# Move particle target down in the list
bpy.ops.particle.target_move_down()
# Move particle target up in the list
bpy.ops.particle.target_move_up()
# Remove the selected particle target
bpy.ops.particle.target_remove()
# Set the weight of selected keys
bpy.ops.particle.weight_set(factor=1)

# Apply the current pose as the new rest pose
bpy.ops.pose.armature_apply()
# Change the visible armature layers
bpy.ops.pose.armature_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Automatically renames the selected bones according to which side of the target axis they fall on
bpy.ops.pose.autoside_names(axis=’XAXIS’)
# Change the layers that the selected bones belong to
bpy.ops.pose.bone_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Create a suitable breakdown pose on the current frame
bpy.ops.pose.breakdown(prev_frame=0, next_frame=0, percentage=0.5)
# Add a constraint to the active bone
bpy.ops.pose.constraint_add(type=’<UNKNOWN ENUM>’)
# Add a constraint to the active bone, with target (where applicable) set to the selected Objects/Bones
bpy.ops.pose.constraint_add_with_targets(type=’<UNKNOWN ENUM>’)
# Clear all the constraints for the selected bones
bpy.ops.pose.constraints_clear()
# Copy constraints to other selected bones
bpy.ops.pose.constraints_copy()
# Copies the current pose of the selected bones to copy/paste buffer
bpy.ops.pose.copy()
# Flips (and corrects) the axis suffixes of the the names of selected bones
bpy.ops.pose.flip_names()
# Add a new bone group
bpy.ops.pose.group_add()
# Add selected bones to the chosen bone group
bpy.ops.pose.group_assign(type=0)
# Deselect bones of active Bone Group
bpy.ops.pose.group_deselect()
# Change position of active Bone Group in list of Bone Groups
bpy.ops.pose.group_move(direction=’UP’)
# Remove the active bone group
bpy.ops.pose.group_remove()
# Select bones in active Bone Group
bpy.ops.pose.group_select()
# Sort Bone Groups by their names in ascending order
bpy.ops.pose.group_sort()
# Remove selected bones from all bone groups
bpy.ops.pose.group_unassign()
# Tag selected bones to not be visible in Pose Mode
bpy.ops.pose.hide(unselected=False)
# Add IK Constraint to the active Bone
bpy.ops.pose.ik_add(with_targets=True)
# Remove all IK Constraints from selected bones
bpy.ops.pose.ik_clear()
# Reset locations of selected bones to their default values
bpy.ops.pose.loc_clear()
# Paste the stored pose on to the current pose
bpy.ops.pose.paste(flipped=False, selected_mask=False)
# Calculate paths for the selected bones
bpy.ops.pose.paths_calculate(start_frame=1, end_frame=250, bake_location=’TAILS’)
# Clear path caches for selected bones
bpy.ops.pose.paths_clear()
# Recalculate paths for bones that already have them
bpy.ops.pose.paths_update()
# Copy selected aspects of the current pose to subsequent poses already keyframed
bpy.ops.pose.propagate(mode=’WHILE_HELD’, end_frame=250)
# Exaggerate the current pose
bpy.ops.pose.push(prev_frame=0, next_frame=0, percentage=0.5)
# Flip quaternion values to achieve desired rotations, while maintaining the same orientations
bpy.ops.pose.quaternions_flip()
# Make the current pose more similar to its surrounding ones
bpy.ops.pose.relax(prev_frame=0, next_frame=0, percentage=0.5)
# Unhide all bones that have been tagged to be hidden in Pose Mode
bpy.ops.pose.reveal()
# Reset rotations of selected bones to their default values
bpy.ops.pose.rot_clear()
# Set the rotation representation used by selected bones
bpy.ops.pose.rotation_mode_set(type=’QUATERNION’)
# Reset scaling of selected bones to their default values
bpy.ops.pose.scale_clear()
# Toggle selection status of all bones
bpy.ops.pose.select_all(action=’TOGGLE’)
# Select bones used as targets for the currently selected bones
bpy.ops.pose.select_constraint_target()
# Activate the bone with a flipped name
bpy.ops.pose.select_flip_active()
# Select all visible bones grouped by similar properties
bpy.ops.pose.select_grouped(extend=False, type=’LAYER’)
# Select immediate parent/children of selected bones
bpy.ops.pose.select_hierarchy(direction=’PARENT’, extend=False)
# Select bones related to selected ones by parent/child relationships
bpy.ops.pose.select_linked(extend=False)
# Select bones that are parents of the currently selected bones
bpy.ops.pose.select_parent()
# Reset location, rotation, and scaling of selected bones to their default values
bpy.ops.pose.transforms_clear()
# Reset pose on selected bones to keyframed state
bpy.ops.pose.user_transforms_clear(only_selected=True)
# Apply final constrained position of pose bones to their transform
bpy.ops.pose.visual_transform_apply()

# Make action suitable for use as a Pose Library
bpy.ops.poselib.action_sanitize()
# Apply specified Pose Library pose to the rig
bpy.ops.poselib.apply_pose(pose_index=-1)
# Interactively browse poses in 3D-View
bpy.ops.poselib.browse_interactive(pose_index=-1)
# Add New Pose Library to active Object
bpy.ops.poselib.new()
# Add the current Pose to the active Pose Library
bpy.ops.poselib.pose_add(frame=1, name=”Pose”)
# Remove nth pose from the active Pose Library
bpy.ops.poselib.pose_remove(pose=’<UNKNOWN ENUM>’)
# Rename specified pose from the active Pose Library
bpy.ops.poselib.pose_rename(name=”RenamedPose”, pose=’<UNKNOWN ENUM>’)
# Remove Pose Library from active Object
bpy.ops.poselib.unlink()

# Add new cache
bpy.ops.ptcache.add()
# Bake physics
bpy.ops.ptcache.bake(bake=False)
# Bake all physics
bpy.ops.ptcache.bake_all(bake=True)
# Bake from cache
bpy.ops.ptcache.bake_from_cache()
# Free physics bake
bpy.ops.ptcache.free_bake()
# Free all baked caches of all objects in the current scene
bpy.ops.ptcache.free_bake_all()
# Delete current cache
bpy.ops.ptcache.remove()

# Add an Integrator Preset
bpy.ops.render.cycles_integrator_preset_add(remove_active=False, name=””)
# OpenGL render active viewport
bpy.ops.render.opengl(animation=False, sequencer=False, write_still=False, view_context=True)
# Play back rendered frames/movies using an external player
bpy.ops.render.play_rendered_anim()
# Add a Render Preset
bpy.ops.render.preset_add(remove_active=False, name=””)
# Render active scene
bpy.ops.render.render(animation=False, write_still=False, layer=””, scene=””)
# Cancel show render view
bpy.ops.render.view_cancel()
# Toggle show render view
bpy.ops.render.view_show()

# Bake rigid body transformations of selected objects to keyframes
bpy.ops.rigidbody.bake_to_keyframes(frame_start=1, frame_end=250, step=1)
# Create rigid body constraints between selected rigid bodies
bpy.ops.rigidbody.connect(con_type=’FIXED’, pivot_type=’CENTER’, connection_pattern=’SELECTED_TO_ACTIVE’)
# Add Rigid Body Constraint to active object
bpy.ops.rigidbody.constraint_add(type=’FIXED’)
# Remove Rigid Body Constraint from Object
bpy.ops.rigidbody.constraint_remove()
# Automatically calculate mass values for Rigid Body Objects based on volume
bpy.ops.rigidbody.mass_calculate(material=’Air’, density=1)
# Add active object as Rigid Body
bpy.ops.rigidbody.object_add(type=’ACTIVE’)
# Remove Rigid Body settings from Object
bpy.ops.rigidbody.object_remove()
# Copy Rigid Body settings from active object to selected
bpy.ops.rigidbody.object_settings_copy()
# Add selected objects as Rigid Bodies
bpy.ops.rigidbody.objects_add(type=’ACTIVE’)
# Remove selected objects from Rigid Body simulation
bpy.ops.rigidbody.objects_remove()
# Change collision shapes for selected Rigid Body Objects
bpy.ops.rigidbody.shape_change(type=’MESH’)
# Add Rigid Body simulation world to the current scene
bpy.ops.rigidbody.world_add()
# Remove Rigid Body simulation world from the current scene
bpy.ops.rigidbody.world_remove()

# Delete active scene
bpy.ops.scene.delete()
# Add the data paths to the Freestyle Edge Mark property of selected edges to the active keying set
bpy.ops.scene.freestyle_add_edge_marks_to_keying_set()
# Add the data paths to the Freestyle Face Mark property of selected polygons to the active keying set
bpy.ops.scene.freestyle_add_face_marks_to_keying_set()
# Add an alpha transparency modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_alpha_modifier_add(type=’ALONG_STROKE’)
# Add a line color modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_color_modifier_add(type=’ALONG_STROKE’)
# Fill the Range Min/Max entries by the min/max distance between selected mesh objects and the source object
bpy.ops.scene.freestyle_fill_range_by_selection(type=’COLOR’, name=””)
# Add a stroke geometry modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_geometry_modifier_add(type=‘2D_OFFSET’)
# Add a line set into the list of line sets
bpy.ops.scene.freestyle_lineset_add()
# Copy the active line set to a buffer
bpy.ops.scene.freestyle_lineset_copy()
# Change the position of the active line set within the list of line sets
bpy.ops.scene.freestyle_lineset_move(direction=’UP’)
# Paste the buffer content to the active line set
bpy.ops.scene.freestyle_lineset_paste()
# Remove the active line set from the list of line sets
bpy.ops.scene.freestyle_lineset_remove()
# Create a new line style, reusable by multiple line sets
bpy.ops.scene.freestyle_linestyle_new()
# Duplicate the modifier within the list of modifiers
bpy.ops.scene.freestyle_modifier_copy()
# Move the modifier within the list of modifiers
bpy.ops.scene.freestyle_modifier_move(direction=’UP’)
# Remove the modifier from the list of modifiers
bpy.ops.scene.freestyle_modifier_remove()
# Add a style module into the list of modules
bpy.ops.scene.freestyle_module_add()
# Change the position of the style module within in the list of style modules
bpy.ops.scene.freestyle_module_move(direction=’UP’)
# Open a style module file
bpy.ops.scene.freestyle_module_open(filepath=””, make_internal=True)
# Remove the style module from the stack
bpy.ops.scene.freestyle_module_remove()
# Add a line thickness modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_thickness_modifier_add(type=’ALONG_STROKE’)
# Add new scene by type
bpy.ops.scene.new(type=’NEW’)
# Add a render layer
bpy.ops.scene.render_layer_add()
# Remove the selected render layer
bpy.ops.scene.render_layer_remove()

# Handle area action zones for mouse actions/gestures
bpy.ops.screen.actionzone(modifier=0)
# Cancel animation, returning to the original frame
bpy.ops.screen.animation_cancel(restore_frame=True)
# Play animation
bpy.ops.screen.animation_play(reverse=False, sync=False)
# Step through animation by position
bpy.ops.screen.animation_step()
# Duplicate selected area into new window
bpy.ops.screen.area_dupli()
# Join selected areas into new window
bpy.ops.screen.area_join(min_x=-100, min_y=-100, max_x=-100, max_y=-100)
# Move selected area edges
bpy.ops.screen.area_move(x=0, y=0, delta=0)
# Operations for splitting and merging
bpy.ops.screen.area_options()
# Split selected area into new windows
bpy.ops.screen.area_split(direction=’HORIZONTAL’, factor=0.5, mouse_x=-100, mouse_y=-100)
# Swap selected areas screen positions
bpy.ops.screen.area_swap()
# Revert back to the original screen layout, before fullscreen area overlay
bpy.ops.screen.back_to_previous()
# Delete active screen
bpy.ops.screen.delete()
# Jump to first/last frame in frame range
bpy.ops.screen.frame_jump(end=False)
# Move current frame forward/backward by a given number
bpy.ops.screen.frame_offset(delta=0)
# Toggle the header over/below the main window area
bpy.ops.screen.header_flip()
# Show or hide the header pulldown menus
bpy.ops.screen.header_toggle_menus()
# Display header region toolbox
bpy.ops.screen.header_toolbox()
# Jump to previous/next keyframe
bpy.ops.screen.keyframe_jump(next=True)
# Add a new screen
bpy.ops.screen.new()
# Display menu for last action performed
bpy.ops.screen.redo_last()
# Blend in and out overlapping region
bpy.ops.screen.region_blend()
# Toggle the region’s alignment (left/right or top/bottom)
bpy.ops.screen.region_flip()
# Split selected area into camera, front, right & top views
bpy.ops.screen.region_quadview()
# Scale selected area
bpy.ops.screen.region_scale()
# Display menu for previous actions performed
bpy.ops.screen.repeat_history(index=0)
# Repeat last action
bpy.ops.screen.repeat_last()
# Toggle display selected area as fullscreen
bpy.ops.screen.screen_full_area()
# Cycle through available screens
bpy.ops.screen.screen_set(delta=0)
# Capture a video of the active area or whole Blender window
bpy.ops.screen.screencast(filepath=””, full=True)
# Capture a picture of the active area or whole Blender window
bpy.ops.screen.screenshot(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, full=True)
# Remove unused settings for invisible editors
bpy.ops.screen.spacedata_cleanup()
# Show user preferences
bpy.ops.screen.userpref_show()

# Ignore autoexec warning
bpy.ops.script.autoexec_warn_clear()
# Execute a preset
bpy.ops.script.execute_preset(filepath=””, menu_idname=””)
# Run Python file
bpy.ops.script.python_file_run(filepath=””)
# Reload Scripts
bpy.ops.script.reload()

# Sculpt a stroke into the geometry
bpy.ops.sculpt.brush_stroke(stroke=[], mode=’NORMAL’, ignore_background_click=False)
# Dynamic topology alters the mesh topology while sculpting
bpy.ops.sculpt.dynamic_topology_toggle()
# Recalculate the sculpt BVH to improve performance
bpy.ops.sculpt.optimize()
# Toggle sculpt mode in 3D view
bpy.ops.sculpt.sculptmode_toggle()
# Reset the copy of the mesh that is being sculpted on
bpy.ops.sculpt.set_persistent_base()
# Symmetrize the topology modifications
bpy.ops.sculpt.symmetrize()
# Sculpt UVs using a brush
bpy.ops.sculpt.uv_sculpt_stroke(mode=’NORMAL’)

#
bpy.ops.sequencer.change_effect_input(swap=’A_B’)
#
bpy.ops.sequencer.change_effect_type(type=’CROSS’)
#
bpy.ops.sequencer.change_path(filepath=””, directory=””, files=[], filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
#
bpy.ops.sequencer.copy()
# Do cross-fading volume animation of two selected sound strips
bpy.ops.sequencer.crossfade_sounds()
# Cut the selected strips
bpy.ops.sequencer.cut(frame=0, type=’SOFT’, side=’BOTH’)
# Cut multi-cam strip and select camera
bpy.ops.sequencer.cut_multicam(camera=1)
# Deinterlace all selected movie sources
bpy.ops.sequencer.deinterlace_selected_movies()
# Erase selected strips from the sequencer
bpy.ops.sequencer.delete()
# Duplicate the selected strips
bpy.ops.sequencer.duplicate(mode=’TRANSLATION’)
# Duplicate selected strips and move them
bpy.ops.sequencer.duplicate_move(SEQUENCER_OT_duplicate={“mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Add an effect to the sequencer, most are applied on top of existing strips
bpy.ops.sequencer.effect_strip_add(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, frame_end=0, channel=1, replace_sel=True, overlap=False, type=’CROSS’, color=(0, 0, 0))
# Insert gap at current frame to first strips at the right, independent of selection or locked state of strips
bpy.ops.sequencer.gap_insert(frames=10)
# Remove gap at current frame to first strip at the right, independent of selection or locked state of strips
bpy.ops.sequencer.gap_remove(all=False)
# Add an image or image sequence to the sequencer
bpy.ops.sequencer.image_strip_add(directory=””, files=[], filter_blender=False, filter_backup=False, filter_image=True, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, frame_end=0, channel=1, replace_sel=True, overlap=False)
# On image sequence strips, it returns a strip for each image
bpy.ops.sequencer.images_separate(length=1)
# Lock the active strip so that it can’t be transformed
bpy.ops.sequencer.lock()
# Add a mask strip to the sequencer
bpy.ops.sequencer.mask_strip_add(frame_start=0, channel=1, replace_sel=True, overlap=False, mask=’<UNKNOWN ENUM>’)
# Group selected strips into a metastrip
bpy.ops.sequencer.meta_make()
# Put the contents of a metastrip back in the sequencer
bpy.ops.sequencer.meta_separate()
# Toggle a metastrip (to edit enclosed strips)
bpy.ops.sequencer.meta_toggle()
# Add a movie strip to the sequencer
bpy.ops.sequencer.movie_strip_add(filepath=””, files=[], filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, channel=1, replace_sel=True, overlap=False, sound=True)
# Add a movieclip strip to the sequencer
bpy.ops.sequencer.movieclip_strip_add(frame_start=0, channel=1, replace_sel=True, overlap=False, clip=’<UNKNOWN ENUM>’)
# Mute selected strips
bpy.ops.sequencer.mute(unselected=False)
# Clear strip offsets from the start and end frames
bpy.ops.sequencer.offset_clear()
#
bpy.ops.sequencer.paste()
# Open sequencer properties panel
bpy.ops.sequencer.properties()
# Reassign the inputs for the effect strip
bpy.ops.sequencer.reassign_inputs()
# Rebuild all selected proxies and timecode indices using the job system
bpy.ops.sequencer.rebuild_proxy()
# Refresh the sequencer editor
bpy.ops.sequencer.refresh_all()
# Reload strips in the sequencer
bpy.ops.sequencer.reload(adjust_length=False)
# Set render size and aspect from active sequence
bpy.ops.sequencer.rendersize()
# Use mouse to sample color in current frame
bpy.ops.sequencer.sample()
# Add a strip to the sequencer using a blender scene as a source
bpy.ops.sequencer.scene_strip_add(frame_start=0, channel=1, replace_sel=True, overlap=False, scene=’Scene’)
# Select a strip (last selected becomes the “active strip”)
bpy.ops.sequencer.select(extend=False, linked_handle=False, left_right=False, linked_time=False)
# Select strips on the nominated side of the active strip
bpy.ops.sequencer.select_active_side(side=’BOTH’)
# Select or deselect all strips
bpy.ops.sequencer.select_all(action=’TOGGLE’)
# Enable border select mode
bpy.ops.sequencer.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select all strips grouped by various properties
bpy.ops.sequencer.select_grouped(extend=False, type=’TYPE’)
# Select manipulator handles on the sides of the selected strip
bpy.ops.sequencer.select_handles(side=’BOTH’)
# Shrink the current selection of adjacent selected strips
bpy.ops.sequencer.select_less()
# Select all strips adjacent to the current selection
bpy.ops.sequencer.select_linked()
# Select a chain of linked strips nearest to the mouse pointer
bpy.ops.sequencer.select_linked_pick(extend=False)
# Select more strips adjacent to the current selection
bpy.ops.sequencer.select_more()
# Frame where selected strips will be snapped
bpy.ops.sequencer.snap(frame=0)
# Add a sound strip to the sequencer
bpy.ops.sequencer.sound_strip_add(filepath=””, files=[], filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, channel=1, replace_sel=True, overlap=False, cache=False)
# Move frame to previous edit point
bpy.ops.sequencer.strip_jump(next=True, center=True)
# Add a modifier to strip
bpy.ops.sequencer.strip_modifier_add(type=’COLOR_BALANCE’)
# Move modifier up and down in the stack
bpy.ops.sequencer.strip_modifier_move(name=”Name”, direction=’UP’)
# Add a modifier to strip
bpy.ops.sequencer.strip_modifier_remove(name=”Name”)
# Swap active strip with strip to the right or left
bpy.ops.sequencer.swap(side=’RIGHT’)
# Swap 2 sequencer strips
bpy.ops.sequencer.swap_data()
# Swap the first two inputs for the effect strip
bpy.ops.sequencer.swap_inputs()
# Unlock the active strip so that it can’t be transformed
bpy.ops.sequencer.unlock()
# Un-Mute unselected rather than selected strips
bpy.ops.sequencer.unmute(unselected=False)
# View all the strips in the sequencer
bpy.ops.sequencer.view_all()
# Zoom preview to fit in the area
bpy.ops.sequencer.view_all_preview()
# Enable border select mode
bpy.ops.sequencer.view_ghost_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Zoom the sequencer on the selected strips
bpy.ops.sequencer.view_selected()
# Toggle between sequencer views (sequence, preview, both)
bpy.ops.sequencer.view_toggle()
# Change zoom ratio of sequencer preview
bpy.ops.sequencer.view_zoom_ratio(ratio=1)

# Cancel the current sketch stroke
bpy.ops.sketch.cancel_stroke()
# Convert the selected sketch strokes to bone chains
bpy.ops.sketch.convert()
# Delete a sketch stroke
bpy.ops.sketch.delete()
# Draw preview of current sketch stroke (internal use)
bpy.ops.sketch.draw_preview(snap=False)
# Start to draw a sketch stroke
bpy.ops.sketch.draw_stroke(snap=False)
# End and keep the current sketch stroke
bpy.ops.sketch.finish_stroke()
# Start to draw a gesture stroke
bpy.ops.sketch.gesture(snap=False)
# Select a sketch stroke
bpy.ops.sketch.select()

# Update the audio animation cache
bpy.ops.sound.bake_animation()
# Mixes the scene’s audio to a sound file
bpy.ops.sound.mixdown(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, accuracy=1024, container=’FLAC’, codec=’FLAC’, format=’S16’, bitrate=192, split_channels=False)
# Load a sound file
bpy.ops.sound.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, cache=False, mono=False)
# Load a sound file as mono
bpy.ops.sound.open_mono(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, cache=False, mono=True)
# Pack the sound into the current blend file
bpy.ops.sound.pack()
# Unpack the sound to the samples filename
bpy.ops.sound.unpack(method=’USE_LOCAL’, id=””)
# Update animation flags
bpy.ops.sound.update_animation_flags()

# Construct a Nurbs surface Circle
bpy.ops.surface.primitive_nurbs_surface_circle_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Curve
bpy.ops.surface.primitive_nurbs_surface_curve_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Cylinder
bpy.ops.surface.primitive_nurbs_surface_cylinder_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Sphere
bpy.ops.surface.primitive_nurbs_surface_sphere_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Patch
bpy.ops.surface.primitive_nurbs_surface_surface_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Torus
bpy.ops.surface.primitive_nurbs_surface_torus_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))

# Show a list of used text in the open document
bpy.ops.text.autocomplete()
# Convert selected text to comment
bpy.ops.text.comment()
# Convert whitespaces by type
bpy.ops.text.convert_whitespace(type=’SPACES’)
# Copy selected text to clipboard
bpy.ops.text.copy()
# Set cursor position
bpy.ops.text.cursor_set(x=0, y=0)
# Cut selected text to clipboard
bpy.ops.text.cut()
# Delete text by cursor position
bpy.ops.text.delete(type=’NEXT_CHARACTER’)
# Duplicate the current line
bpy.ops.text.duplicate_line()
# Find specified text
bpy.ops.text.find()
# Find specified text and set as selected
bpy.ops.text.find_set_selected()
# Indent selected text
bpy.ops.text.indent()
# Insert text at cursor position
bpy.ops.text.insert(text=””)
# Jump cursor to line
bpy.ops.text.jump(line=1)
# Insert line break at cursor position
bpy.ops.text.line_break()
# The current line number
bpy.ops.text.line_number()
# Make active text file internal
bpy.ops.text.make_internal()
# Move cursor to position type
bpy.ops.text.move(type=’LINE_BEGIN’)
# Move the currently selected line(s) up/down
bpy.ops.text.move_lines(direction=’DOWN’)
# Make selection from current cursor position to new cursor position type
bpy.ops.text.move_select(type=’LINE_BEGIN’)
# Create a new text data block
bpy.ops.text.new()
# Open a new text data block
bpy.ops.text.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=True, filter_font=False, filter_sound=False, filter_text=True, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, internal=False)
# Toggle overwrite while typing
bpy.ops.text.overwrite_toggle()
# Paste text from clipboard
bpy.ops.text.paste(selection=False)
# Toggle text properties panel
bpy.ops.text.properties()
# Refresh all pyconstraints
bpy.ops.text.refresh_pyconstraints()
# Reload active text data block from its file
bpy.ops.text.reload()
# Replace text with the specified text
bpy.ops.text.replace()
# Replace text with specified text and set as selected
bpy.ops.text.replace_set_selected()
# When external text is out of sync, resolve the conflict
bpy.ops.text.resolve_conflict(resolution=’IGNORE’)
# Run active script
bpy.ops.text.run_script()
# Save active text data block
bpy.ops.text.save()
# Save active text file with options
bpy.ops.text.save_as(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=True, filter_font=False, filter_sound=False, filter_text=True, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Scroll text screen
bpy.ops.text.scroll(lines=1)
# Scroll text screen
bpy.ops.text.scroll_bar(lines=1)
# Select all text
bpy.ops.text.select_all()
# Select text by line
bpy.ops.text.select_line()
# Select word under cursor
bpy.ops.text.select_word()
# Set cursor selection
bpy.ops.text.selection_set(select=False)
# Start searching text
bpy.ops.text.start_find()
# Create 3D text object from active text data block
bpy.ops.text.to_3d_object(split_lines=False)
# Convert selected comment to text
bpy.ops.text.uncomment()
# Unindent selected text
bpy.ops.text.unindent()
# Unlink active text data block
bpy.ops.text.unlink()

# Discard the environment map and free it from memory
bpy.ops.texture.envmap_clear()
# Discard all environment maps in the .blend file and free them from memory
bpy.ops.texture.envmap_clear_all()
# Save the current generated Environment map to an image file
bpy.ops.texture.envmap_save(layout=(0, 0, 1, 0, 2, 0, 0, 1, 1, 1, 2, 1), filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Add a new texture
bpy.ops.texture.new()
# Copy the material texture settings and nodes
bpy.ops.texture.slot_copy()
# Move texture slots up and down
bpy.ops.texture.slot_move(type=’UP’)
# Copy the texture settings and nodes
bpy.ops.texture.slot_paste()

# Set the end frame
bpy.ops.time.end_frame_set()
# Set the start frame
bpy.ops.time.start_frame_set()
# Show the entire playable frame range
bpy.ops.time.view_all()

# Create transformation orientation from selection
bpy.ops.transform.create_orientation(name=””, use_view=False, use=False, overwrite=False)
# Delete transformation orientation
bpy.ops.transform.delete_orientation()
# Change the bevel weight of edges
bpy.ops.transform.edge_bevelweight(value=0, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Change the crease of edges
bpy.ops.transform.edge_crease(value=0, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Slide an edge loop along a mesh
bpy.ops.transform.edge_slide(value=0, mirror=False, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), correct_uv=False, release_confirm=False)
# Mirror selected vertices around one or more axes
bpy.ops.transform.mirror(constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, release_confirm=False)
# Push/Pull selected items
bpy.ops.transform.push_pull(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Scale (resize) selected items
bpy.ops.transform.resize(value=(1, 1, 1), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), texture_space=False, release_confirm=False)
# Rotate selected items
bpy.ops.transform.rotate(value=0, axis=(0, 0, 0), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Select transformation orientation
bpy.ops.transform.select_orientation(orientation=’GLOBAL’)
# Slide a sequence strip in time
bpy.ops.transform.seq_slide(value=(0, 0), snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Shear selected items along the horizontal screen axis
bpy.ops.transform.shear(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Shrink/fatten selected vertices along normals
bpy.ops.transform.shrink_fatten(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Scale selected vertices’ skin radii
bpy.ops.transform.skin_resize(value=(1, 1, 1), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), texture_space=False, release_confirm=False)
# Tilt selected control vertices of 3D curve
bpy.ops.transform.tilt(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Move selected vertices outward in a spherical shape around mesh center
bpy.ops.transform.tosphere(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Trackball style rotation of selected items
bpy.ops.transform.trackball(value=(0, 0), mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Transform selected items by mode type
bpy.ops.transform.transform(mode=’TRANSLATION’, value=(0, 0, 0, 0), axis=(0, 0, 0), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Translate (move) selected items
bpy.ops.transform.translate(value=(0, 0, 0), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), texture_space=False, release_confirm=False)
# Slide a vertex along a mesh
bpy.ops.transform.vert_slide(value=0, mirror=False, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Warp selected items around the cursor
bpy.ops.transform.warp(value=(0,), mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)

# Copy the RNA data path for this property to the clipboard
bpy.ops.ui.copy_data_path_button()
# Copy property from this object to selected objects or bones
bpy.ops.ui.copy_to_selected_button(all=True)
# Edit UI source code of the active button
bpy.ops.ui.editsource()
# Edit i18n in current language for the active button
bpy.ops.ui.edittranslation_init()
# Sample a color from the Blender Window to store in a property
bpy.ops.ui.eyedropper()
# Force a full reload of UI translation
bpy.ops.ui.reloadtranslation()
# Write the reports
bpy.ops.ui.reports_to_textblock()
# Reset this property’s value to its default value
bpy.ops.ui.reset_default_button(all=True)
# Reset to the default theme colors
bpy.ops.ui.reset_default_theme()

# Align selected UV vertices to an axis
bpy.ops.uv.align(axis=’ALIGN_AUTO’)
# Average the size of separate UV islands, based on their area in 3D space
bpy.ops.uv.average_islands_scale()
# Select UV vertices using circle selection
bpy.ops.uv.circle_select(x=0, y=0, radius=0, gesture_mode=0)
# Project the UV vertices of the mesh over the six faces of a cube
bpy.ops.uv.cube_project(cube_size=1, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Set 2D cursor location
bpy.ops.uv.cursor_set(location=(0, 0))
# Project the UV vertices of the mesh over the curved wall of a cylinder
bpy.ops.uv.cylinder_project(direction=’VIEW_ON_EQUATOR’, align=’POLAR_ZX’, radius=1, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Export UV layout to file
bpy.ops.uv.export_layout(filepath=””, check_existing=True, export_all=False, modified=False, mode=’PNG’, size=(1024, 1024), opacity=0.25, tessellated=False)
# Follow UVs from active quads along continuous face loops
bpy.ops.uv.follow_active_quads(mode=’LENGTH_AVERAGE’)
# Hide (un)selected UV vertices
bpy.ops.uv.hide(unselected=False)
# Follow UVs from active quads along continuous face loops
bpy.ops.uv.lightmap_pack(PREF_CONTEXT=’SEL_FACES’, PREF_PACK_IN_ONE=True, PREF_NEW_UVLAYER=False, PREF_APPLY_IMAGE=False, PREF_IMG_PX_SIZE=512, PREF_BOX_DIV=12, PREF_MARGIN_DIV=0.1)
# Mark selected UV edges as seams
bpy.ops.uv.mark_seam()
# Reduce UV stretching by relaxing angles
bpy.ops.uv.minimize_stretch(fill_holes=True, blend=0, iterations=0)
# Transform all islands so that they fill up the UV space as much as possible
bpy.ops.uv.pack_islands(margin=0.001)
# Set/clear selected UV vertices as anchored between multiple unwrap operations
bpy.ops.uv.pin(clear=False)
# Project the UV vertices of the mesh as seen in current 3D view
bpy.ops.uv.project_from_view(orthographic=False, camera_bounds=True, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Selected UV vertices that are within a radius of each other are welded together
bpy.ops.uv.remove_doubles(threshold=0.02, use_unselected=False)
# Reset UV projection
bpy.ops.uv.reset()
# Reveal all hidden UV vertices
bpy.ops.uv.reveal()
# Set mesh seams according to island setup in the UV editor
bpy.ops.uv.seams_from_islands(mark_seams=True, mark_sharp=False)
# Select UV vertices
bpy.ops.uv.select(extend=False, location=(0, 0))
# Change selection of all UV vertices
bpy.ops.uv.select_all(action=’TOGGLE’)
# Select UV vertices using border selection
bpy.ops.uv.select_border(pinned=False, gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select UVs using lasso selection
bpy.ops.uv.select_lasso(path=[], deselect=False, extend=True)
# Deselect UV vertices at the boundary of each selection region
bpy.ops.uv.select_less()
# Select all UV vertices linked to the active UV map
bpy.ops.uv.select_linked(extend=False)
# Select all UV vertices linked under the mouse
bpy.ops.uv.select_linked_pick(extend=False, location=(0, 0))
# Select a loop of connected UV vertices
bpy.ops.uv.select_loop(extend=False, location=(0, 0))
# Select more UV vertices connected to initial selection
bpy.ops.uv.select_more()
# Select all pinned UV vertices
bpy.ops.uv.select_pinned()
# Select only entirely selected faces
bpy.ops.uv.select_split()
# This script projection unwraps the selected faces of a mesh (it operates on all selected mesh objects, and can be used to unwrap selected faces, or all faces)
bpy.ops.uv.smart_project(angle_limit=66, island_margin=0, user_area_weight=0)
# Snap cursor to target type
bpy.ops.uv.snap_cursor(target=’PIXELS’)
# Snap selected UV vertices to target type
bpy.ops.uv.snap_selected(target=’PIXELS’)
# Project the UV vertices of the mesh over the curved surface of a sphere
bpy.ops.uv.sphere_project(direction=’VIEW_ON_EQUATOR’, align=’POLAR_ZX’, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Stitch selected UV vertices by proximity
bpy.ops.uv.stitch(use_limit=False, snap_islands=True, limit=0.01, static_island=0, midpoint_snap=False, clear_seams=True, mode=’VERTEX’, stored_mode=’VERTEX’, selection=[])
# Set UV image tile coordinates
bpy.ops.uv.tile_set(tile=(0, 0))
# Unwrap the mesh of the object being edited
bpy.ops.uv.unwrap(method=’ANGLE_BASED’, fill_holes=True, correct_aspect=True, use_subsurf_data=False, margin=0.001)
# Weld selected UV vertices together
bpy.ops.uv.weld()

# Pan the view
bpy.ops.view2d.pan(deltax=0, deltay=0)
# Reset the view
bpy.ops.view2d.reset()
# Scroll the view down
bpy.ops.view2d.scroll_down(deltax=0, deltay=0, page=False)
# Scroll the view left
bpy.ops.view2d.scroll_left(deltax=0, deltay=0)
# Scroll the view right
bpy.ops.view2d.scroll_right(deltax=0, deltay=0)
# Scroll the view up
bpy.ops.view2d.scroll_up(deltax=0, deltay=0, page=False)
# Scroll view by mouse click and drag
bpy.ops.view2d.scroller_activate()
# Zoom in the view to the nearest item contained in the border
bpy.ops.view2d.smoothview(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Zoom in/out the view
bpy.ops.view2d.zoom(deltax=0, deltay=0)
# Zoom in the view to the nearest item contained in the border
bpy.ops.view2d.zoom_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Zoom in the view
bpy.ops.view2d.zoom_in(zoomfacx=0, zoomfacy=0)
# Zoom out the view
bpy.ops.view2d.zoom_out(zoomfacx=0, zoomfacy=0)

# Add a new background image
bpy.ops.view3d.background_image_add(name=”Image”, filepath=”Path”)
# Remove a background image from the 3D view
bpy.ops.view3d.background_image_remove(index=0)
# Set camera view to active view
bpy.ops.view3d.camera_to_view()
# Move the camera so selected objects are framed
bpy.ops.view3d.camera_to_view_selected()
# Clear the boundaries of the border render and disable border render
bpy.ops.view3d.clear_render_border()
# Set the view clipping border
bpy.ops.view3d.clip_border(xmin=0, xmax=0, ymin=0, ymax=0)
# Selected objects are saved in a temp file
bpy.ops.view3d.copybuffer()
# Set the location of the 3D cursor
bpy.ops.view3d.cursor3d()
# Dolly in/out in the view
bpy.ops.view3d.dolly(delta=0, mx=0, my=0)
# Extrude individual elements and move
bpy.ops.view3d.edit_mesh_extrude_individual_move()
# Extrude and move along normals
bpy.ops.view3d.edit_mesh_extrude_move_normal()
# Enable the transform manipulator for use
bpy.ops.view3d.enable_manipulator(translate=False, rotate=False, scale=False)
# Interactively fly around the scene
bpy.ops.view3d.fly()
# Start game engine
bpy.ops.view3d.game_start()
# Toggle layer(s) visibility
bpy.ops.view3d.layers(nr=1, extend=False, toggle=True)
# Toggle display of selected object(s) separately and centered in view
bpy.ops.view3d.localview()
# Manipulate selected item by axis
bpy.ops.view3d.manipulator(constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, release_confirm=False)
# Move the view
bpy.ops.view3d.move()
# Position your viewpoint with the 3D mouse
bpy.ops.view3d.ndof_all()
# Explore every angle of an object using the 3D mouse
bpy.ops.view3d.ndof_orbit()
# Explore every angle of an object using the 3D mouse
bpy.ops.view3d.ndof_orbit_zoom()
# Position your viewpoint with the 3D mouse
bpy.ops.view3d.ndof_pan()
# Set the active object as the active camera for this view or scene
bpy.ops.view3d.object_as_camera()
# Contents of copy buffer gets pasted
bpy.ops.view3d.pastebuffer()
# Toggles the properties panel display
bpy.ops.view3d.properties()
# Set the boundaries of the border render and enable border render
bpy.ops.view3d.render_border(xmin=0, xmax=0, ymin=0, ymax=0, camera_only=False)
# Rotate the view
bpy.ops.view3d.rotate()
# Interactive ruler
bpy.ops.view3d.ruler()
# Activate/select item(s)
bpy.ops.view3d.select(extend=False, deselect=False, toggle=False, center=False, enumerate=False, object=False, location=(0, 0))
# Select items using border selection
bpy.ops.view3d.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select items using circle selection
bpy.ops.view3d.select_circle(x=0, y=0, radius=0, gesture_mode=0)
# Select items using lasso selection
bpy.ops.view3d.select_lasso(path=[], deselect=False, extend=True)
# Menu object selection
bpy.ops.view3d.select_menu(name=’<UNKNOWN ENUM>’, toggle=False)
# Select element under the mouse, deselect everything is there’s nothing under the mouse
bpy.ops.view3d.select_or_deselect_all(extend=False, toggle=False, deselect=False, center=False, enumerate=False, object=False)
# The time to animate the change of view (in milliseconds)
bpy.ops.view3d.smoothview()
# Snap cursor to active item
bpy.ops.view3d.snap_cursor_to_active()
# Snap cursor to the Center
bpy.ops.view3d.snap_cursor_to_center()
# Snap cursor to nearest grid node
bpy.ops.view3d.snap_cursor_to_grid()
# Snap cursor to center of selected item(s)
bpy.ops.view3d.snap_cursor_to_selected()
# Snap selected item(s) to cursor
bpy.ops.view3d.snap_selected_to_cursor()
# Snap selected item(s) to nearest grid node
bpy.ops.view3d.snap_selected_to_grid()
# Toggles tool shelf display
bpy.ops.view3d.toolshelf()
# View all objects in scene
bpy.ops.view3d.view_all(use_all_regions=False, center=False)
# Center the camera view
bpy.ops.view3d.view_center_camera()
# Center the view so that the cursor is in the middle of the view
bpy.ops.view3d.view_center_cursor()
# Center the view to the Z-depth position under the mouse cursor
bpy.ops.view3d.view_center_pick()
# Clear all view locking
bpy.ops.view3d.view_lock_clear()
# Lock the view to the active object/bone
bpy.ops.view3d.view_lock_to_active()
# Orbit the view
bpy.ops.view3d.view_orbit(type=’ORBITLEFT’)
# Pan the view
bpy.ops.view3d.view_pan(type=’PANLEFT’)
# Switch the current view from perspective/orthographic projection
bpy.ops.view3d.view_persportho()
# Move the view to the selection center
bpy.ops.view3d.view_selected(use_all_regions=False)
# Use a preset viewpoint
bpy.ops.view3d.viewnumpad(type=’FRONT’, align_active=False)
# Zoom in/out in the view
bpy.ops.view3d.zoom(delta=0, mx=0, my=0)
# Zoom in the view to the nearest object contained in the border
bpy.ops.view3d.zoom_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Match the camera to 1:1 to the render output
bpy.ops.view3d.zoom_camera_1_to_1()

# Disable an addon
bpy.ops.wm.addon_disable(module=””)
# Enable an addon
bpy.ops.wm.addon_enable(module=””)
# Display more information on this addon
bpy.ops.wm.addon_expand(module=””)
# Install an addon
bpy.ops.wm.addon_install(overwrite=True, target=’DEFAULT’, filepath=””, filter_folder=True, filter_python=True, filter_glob=”.py;.zip”)
# Disable an addon
bpy.ops.wm.addon_remove(module=””)
#
bpy.ops.wm.appconfig_activate(filepath=””)
#
bpy.ops.wm.appconfig_default()
# Launch the blender-player with the current blend-file
bpy.ops.wm.blenderplayer_start()
# Call (draw) a pre-defined menu
bpy.ops.wm.call_menu(name=””)
# Save a Collada file
bpy.ops.wm.collada_export(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=True, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, apply_modifiers=False, export_mesh_type=0, export_mesh_type_selection=’view’, selected=False, include_children=False, include_armatures=False, include_shapekeys=True, deform_bones_only=False, active_uv_only=False, include_uv_textures=False, include_material_textures=False, use_texture_copies=True, triangulate=True, use_object_instantiation=True, sort_by_name=False, export_transformation_type=0, export_transformation_type_selection=’matrix’, second_life=False)
# Load a Collada file
bpy.ops.wm.collada_import(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=True, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, import_units=False)
# Set boolean values for a collection of items
bpy.ops.wm.context_collection_boolean_set(data_path_iter=””, data_path_item=””, type=’TOGGLE’)
# Set a context array value (useful for cycling the active mesh edit mode)
bpy.ops.wm.context_cycle_array(data_path=””, reverse=False)
# Toggle a context value
bpy.ops.wm.context_cycle_enum(data_path=””, reverse=False)
# Set a context value (useful for cycling active material, vertex keys, groups, etc.)
bpy.ops.wm.context_cycle_int(data_path=””, reverse=False)
#
bpy.ops.wm.context_menu_enum(data_path=””)
# Adjust arbitrary values with mouse input
bpy.ops.wm.context_modal_mouse(data_path_iter=””, data_path_item=””, header_text=””, input_scale=0.01, invert=False, initial_x=0)
# Scale an int context value
bpy.ops.wm.context_scale_int(data_path=””, value=1, always_step=True)
# Set a context value
bpy.ops.wm.context_set_boolean(data_path=””, value=True)
# Set a context value
bpy.ops.wm.context_set_enum(data_path=””, value=””)
# Set a context value
bpy.ops.wm.context_set_float(data_path=””, value=0, relative=False)
# Toggle a context value
bpy.ops.wm.context_set_id(data_path=””, value=””)
# Set a context value
bpy.ops.wm.context_set_int(data_path=””, value=0, relative=False)
# Set a context value
bpy.ops.wm.context_set_string(data_path=””, value=””)
# Set a context value
bpy.ops.wm.context_set_value(data_path=””, value=””)
# Toggle a context value
bpy.ops.wm.context_toggle(data_path=””)
# Toggle a context value
bpy.ops.wm.context_toggle_enum(data_path=””, value_1=””, value_2=””)
# Copy settings from previous version
bpy.ops.wm.copy_prev_settings()
# Open a popup to set the debug level
bpy.ops.wm.debug_menu(debug_value=0)
# Print dependency graph relations to the console
bpy.ops.wm.dependency_relations()
# Load online reference docs
bpy.ops.wm.doc_edit(doc_id=””, doc_new=””)
# Load online reference docs
bpy.ops.wm.doc_view(doc_id=””)
# Load online manual
bpy.ops.wm.doc_view_manual(doc_id=””)
# Add an Application Interaction Preset
bpy.ops.wm.interaction_preset_add(remove_active=False, name=””)
# Add a theme preset
bpy.ops.wm.interface_theme_preset_add(remove_active=False, name=””)
#
bpy.ops.wm.keyconfig_activate(filepath=””)
# Export key configuration to a python script
bpy.ops.wm.keyconfig_export(filepath=”keymap.py”, filter_folder=True, filter_text=True, filter_python=True)
# Import key configuration from a python script
bpy.ops.wm.keyconfig_import(filepath=”keymap.py”, filter_folder=True, filter_text=True, filter_python=True, keep_original=True)
# Add a Key-config Preset
bpy.ops.wm.keyconfig_preset_add(remove_active=False, name=””)
# Remove key config
bpy.ops.wm.keyconfig_remove()
# Test key-config for conflicts
bpy.ops.wm.keyconfig_test()
# Add key map item
bpy.ops.wm.keyitem_add()
# Remove key map item
bpy.ops.wm.keyitem_remove(item_id=0)
# Restore key map item
bpy.ops.wm.keyitem_restore(item_id=0)
# Restore key map(s)
bpy.ops.wm.keymap_restore(all=False)
# Link or Append from a Library .blend file
bpy.ops.wm.link_append(filepath=””, directory=””, filename=””, files=[], filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=1, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, link=True, autoselect=True, active_layer=True, instance_groups=True)
# Print memory statistics to the console
bpy.ops.wm.memory_statistics()
# Change NDOF sensitivity
bpy.ops.wm.ndof_sensitivity_change(decrease=True, fast=False)
# Open a Blender file
bpy.ops.wm.open_mainfile(filepath=””, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, load_ui=True, use_scripts=True)
#
bpy.ops.wm.operator_cheat_sheet()
# Set the active operator to its default values
bpy.ops.wm.operator_defaults()
# Add an Operator Preset
bpy.ops.wm.operator_preset_add(remove_active=False, name=””, operator=””)
# Open a path in a file browser
bpy.ops.wm.path_open(filepath=””)
#
bpy.ops.wm.properties_add(data_path=””)
# Jump to a different tab inside the properties editor
bpy.ops.wm.properties_context_change(context=””)
#
bpy.ops.wm.properties_edit(data_path=””, property=””, value=””, min=0, max=1, description=””)
# Internal use (edit a property data_path)
bpy.ops.wm.properties_remove(data_path=””, property=””)
# Quit Blender
bpy.ops.wm.quit_blender()
# Set some size property (like e.g. brush size) with mouse wheel
bpy.ops.wm.radial_control(data_path_primary=””, data_path_secondary=””, use_secondary=””, rotation_path=””, color_path=””, fill_color_path=””, zoom_path=””, image_id=””)
# Load default file and user preferences
bpy.ops.wm.read_factory_settings()
# Reloads history and bookmarks
bpy.ops.wm.read_history()
# Open the default file (doesn’t save the current file)
bpy.ops.wm.read_homefile()
# Open an automatically saved file to recover it
bpy.ops.wm.recover_auto_save(filepath=””, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=8, display_type=’FILE_LONGDISPLAY’)
# Open the last closed file (“quit.blend”)
bpy.ops.wm.recover_last_session()
# Simple redraw timer to test the speed of updating the interface
bpy.ops.wm.redraw_timer(type=’DRAW’, iterations=10)
# Save the current file in the desired location
bpy.ops.wm.save_as_mainfile(filepath=””, check_existing=True, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, compress=False, relative_remap=True, copy=False, use_mesh_compat=False)
# Make the current file the default .blend file, includes preferences
bpy.ops.wm.save_homefile()
# Save the current Blender file
bpy.ops.wm.save_mainfile(filepath=””, check_existing=True, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, compress=False, relative_remap=False)
# Save user preferences separately, overrides startup file preferences
bpy.ops.wm.save_userpref()
# Pop-up a search menu over all available operators in current context
bpy.ops.wm.search_menu()
# Opens a blocking popup region with release info
bpy.ops.wm.splash()
# Generate System Info
bpy.ops.wm.sysinfo()
# Load and apply a Blender XML theme file
bpy.ops.wm.theme_install(overwrite=True, filepath=””, filter_folder=True, filter_glob=”*.xml”)
# Open a website in the web-browser
bpy.ops.wm.url_open(url=””)
# (undocumented operator)
bpy.ops.wm.userpref_autoexec_path_add()
# (undocumented operator)
bpy.ops.wm.userpref_autoexec_path_remove(index=0)
# Duplicate the current Blender window
bpy.ops.wm.window_duplicate()
# Toggle the current window fullscreen
bpy.ops.wm.window_fullscreen_toggle()

# Add a new world

bpy.ops.world.new()

Operator list¶

Objectives¶

Instructions¶

Call the menu¶

List of operators¶

Table Of Contents