Dan's Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Python Operators from Blender ======

<code python>

# 1673 Operators

# Simplify F-Curves by removing closely spaced keyframes
bpy.ops.action.clean(threshold=0.001, channels=False)
# Select keyframes by clicking on them
bpy.ops.action.clickselect(extend=False, column=False, channel=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), "gpencil_strokes":False, "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')
# Switch to editing action in animation layer above the current action in the NLA Stack
bpy.ops.action.layer_next()
# Switch to editing action in animation layer below the current action in the NLA Stack
bpy.ops.action.layer_prev()
# 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', flipped=False)
# Set Preview Range based on extents of selected Keyframes
bpy.ops.action.previewrange_set()
# Push action down on to the NLA stack as a new strip
bpy.ops.action.push_down()
# 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')
# Store this action in the NLA stack as a non-contributing strip for later use
bpy.ops.action.stash(create_new=True)
# Store this action in the NLA stack as a non-contributing strip for later use, and create a new action
bpy.ops.action.stash_and_create()
# Unlink this action from the active action slot (and/or exit Tweak Mode)
bpy.ops.action.unlink(force_delete=False)
# Reset viewable area to show full keyframe range
bpy.ops.action.view_all()
# Reset viewable area to show range around current frame
bpy.ops.action.view_frame()
# 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, snap=False)
# Select all keyframes of channel under mouse
bpy.ops.anim.channel_select_keys(extend=False)
# Delete all empty animation data containers from visible datablocks
bpy.ops.anim.channels_clean_empty()
# 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()
# Filter the set of channels shown to only include those with matching names
bpy.ops.anim.channels_find(query="Query")
# 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()
# 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 and bones
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 fcurves/drivers affecting Transform constraints (use it with files from 2.70 and earlier)
bpy.ops.anim.update_animated_transform_constraints(use_convert_to_radians=True)

# 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='POS_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()
# Dissolve selected bones from the armature
bpy.ops.armature.dissolve()
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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)
# Deselect those bones at the boundary of each selection region
bpy.ops.armature.select_less()
# Select bones related to selected ones by parent/child relationships
bpy.ops.armature.select_linked(extend=False)
# Mirror the bone selection
bpy.ops.armature.select_mirror(only_active=False, extend=False)
# Select those bones connected to the initial selection
bpy.ops.armature.select_more()
# 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()
# Select shortest path between two bones
bpy.ops.armature.shortest_path_pick()
# Split off selected bones from connected unselected bones
bpy.ops.armature.split()
# 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()
# Enforce symmetry, make copies of the selection or use existing
bpy.ops.armature.symmetrize(direction='NEGATIVE_X')

# 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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# Display button panel toolbox
bpy.ops.buttons.toolbox()

# Add or remove a Camera Preset
bpy.ops.camera.preset_add(name="", remove_active=False, use_focal_length=False)

# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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 or remove a Tracking Camera Intrinsics Preset
bpy.ops.clip.camera_preset_add(name="", remove_active=False, use_focal_length=True)
# 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()
# Create new plane track out of selected point tracks
bpy.ops.clip.create_plane_track()
# Set 2D cursor location
bpy.ops.clip.cursor_set(location=(0, 0))
# 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, threshold=0.5, 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()
# Filter tracks which has weirdly looking spikes in motion curves
bpy.ops.clip.filter_tracks(track_threshold=5)
# 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 track corresponding to the selected curve
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()
# Delete a keyframe from selected tracks at current frame
bpy.ops.clip.keyframe_delete()
# Insert a keyframe to selected tracks at current frame
bpy.ops.clip.keyframe_insert()
# 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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=1, 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)
# 
bpy.ops.clip.set_active_clip()
# Set direction of scene axis rotating camera (or its parent if present) and assume 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 its 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 its parent if present) in 3D space
bpy.ops.clip.set_plane(plane='FLOOR')
# Set scale of scene by scaling camera (or its 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))
# Slide plane marker areas
bpy.ops.clip.slide_plane_marker()
# 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 tracks 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 or remove a Clip Track Color Preset
bpy.ops.clip.track_color_preset_add(name="", remove_active=False)
# 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()
# Copy tracking settings from active track to selected tracks
bpy.ops.clip.track_settings_to_track()
# 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 or remove a motion tracking settings preset
bpy.ops.clip.tracking_settings_preset_add(name="", remove_active=False)
# 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 or remove a Cloth Preset
bpy.ops.cloth.preset_add(name="", remove_active=False)

# 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()
# Select word at cursor position
bpy.ops.console.select_word()
# 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='VERT')
# Duplicate selected control points
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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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()
# Match texture space to object's bounding box
bpy.ops.curve.match_texture_space()
# Recalculate the direction of selected handles
bpy.ops.curve.normals_make_consistent(calc_length=False)
# Construct a Bezier Circle
bpy.ops.curve.primitive_bezier_circle_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 Bezier Curve
bpy.ops.curve.primitive_bezier_curve_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 Nurbs Circle
bpy.ops.curve.primitive_nurbs_circle_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 Nurbs Curve
bpy.ops.curve.primitive_nurbs_curve_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 Path
bpy.ops.curve.primitive_nurbs_path_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))
# 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, skip=1, offset=0)
# 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, seed=0, action='SELECT')
# Select a row of control points including active one
bpy.ops.curve.select_row()
# Select similar curve points by property type
bpy.ops.curve.select_similar(type='WEIGHT', compare='EQUAL', threshold=0.1)
# Separate selected points from connected unselected points 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()
# Select shortest path between two selections
bpy.ops.curve.shortest_path_pick()
# Flatten angles of selected points
bpy.ops.curve.smooth()
# Interpolate radii of selected points
bpy.ops.curve.smooth_radius()
# Interpolate tilt of selected points
bpy.ops.curve.smooth_tilt()
# Interpolate weight of selected points
bpy.ops.curve.smooth_weight()
# 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)
# Split off selected points from connected unselected points
bpy.ops.curve.split()
# 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')

# Flush edit data from active editing modes
bpy.ops.ed.flush_edits()
# 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(filepath="", check_existing=True, 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(filepath="", check_existing=True, axis_forward='Y', axis_up='Z', filter_glob="*.ply", use_mesh_modifiers=True, use_normals=True, use_uv_coords=True, use_colors=True, global_scale=1)
# Save STL triangle mesh data from the active object
bpy.ops.export_mesh.stl(filepath="", check_existing=True, axis_forward='Y', axis_up='Z', filter_glob="*.stl", use_selection=False, global_scale=1, use_scene_unit=False, ascii=False, use_mesh_modifiers=True, batch_mode='OFF')

# Export to 3DS file format (.3ds)
bpy.ops.export_scene.autodesk_3ds(filepath="", check_existing=True, axis_forward='Y', axis_up='Z', filter_glob="*.3ds", use_selection=False)
# Write a FBX file
bpy.ops.export_scene.fbx(filepath="", check_existing=True, axis_forward='-Z', axis_up='Y', filter_glob="*.fbx", version='BIN7400', ui_tab='MAIN', use_selection=False, global_scale=1, apply_unit_scale=True, bake_space_transform=False, object_types={'EMPTY', 'CAMERA', 'LAMP', 'ARMATURE', 'MESH', 'OTHER'}, use_mesh_modifiers=True, mesh_smooth_type='OFF', use_mesh_edges=False, use_tspace=False, use_custom_props=False, add_leaf_bones=True, primary_bone_axis='Y', secondary_bone_axis='X', use_armature_deform_only=False, armature_nodetype='NULL', bake_anim=True, bake_anim_use_all_bones=True, bake_anim_use_nla_strips=True, bake_anim_use_all_actions=True, bake_anim_force_startend_keying=True, bake_anim_step=1, bake_anim_simplify_factor=1, use_anim=True, use_anim_action_all=True, use_default_take=True, use_anim_optimize=True, anim_optimize_precision=6, path_mode='AUTO', embed_textures=False, batch_mode='OFF', use_batch_own_dir=True, use_metadata=True)
# Save a Wavefront OBJ File
bpy.ops.export_scene.obj(filepath="", check_existing=True, axis_forward='-Z', axis_up='Y', filter_glob="*.obj;*.mtl", use_selection=False, use_animation=False, use_mesh_modifiers=True, use_edges=True, use_smooth_groups=False, use_smooth_groups_bitflags=False, use_normals=True, 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, global_scale=1, path_mode='AUTO')
# Export selection to Extensible 3D file (.x3d)
bpy.ops.export_scene.x3d(filepath="", check_existing=True, axis_forward='Z', axis_up='Y', 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, global_scale=1, path_mode='AUTO')

# Automatically pack all external files into the .blend file
bpy.ops.file.autopack_toggle()
# Add a bookmark for the selected/active directory
bpy.ops.file.bookmark_add()
# Delete all invalid bookmarks
bpy.ops.file.bookmark_cleanup()
# Delete selected bookmark
bpy.ops.file.bookmark_delete(index=-1)
# Move the active bookmark up/down in the list
bpy.ops.file.bookmark_move(direction='TOP')
# Toggle bookmarks display
bpy.ops.file.bookmark_toggle()
# Cancel loading of selected file
bpy.ops.file.cancel()
# Delete selected files
bpy.ops.file.delete()
# Create a new directory
bpy.ops.file.directory_new(directory="", open=False)
# Execute selected file
bpy.ops.file.execute(need_active=False)
# Increment number in filename
bpy.ops.file.filenum(increment=1)
# 
bpy.ops.file.filepath_drop(filepath="Path")
# 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, filter_blenlib=False, filemode=9, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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)
# Select/Deselect files by walking through them
bpy.ops.file.select_walk(direction='UP', extend=False, fill=False)
# 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 or remove a Fluid Preset
bpy.ops.fluid.preset_add(name="", remove_active=False)

# 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')
# Insert line break at cursor position
bpy.ops.font.line_break()
# Move cursor to position type
bpy.ops.font.move(type='LINE_BEGIN')
# Move the cursor while selecting
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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# Select all text
bpy.ops.font.select_all()
# 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()
# Paste contents from file
bpy.ops.font.text_paste_from_file(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, filter_blenlib=False, filemode=9, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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()
# Apply tweaks to strokes by painting over the strokes
bpy.ops.gpencil.brush_paint(stroke=[], wait_for_input=True)
# 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)
# Copy selected Grease Pencil points and strokes
bpy.ops.gpencil.copy()
# Add new Grease Pencil datablock
bpy.ops.gpencil.data_add()
# Unlink active Grease Pencil datablock
bpy.ops.gpencil.data_unlink()
# Delete selected Grease Pencil strokes, vertices, or frames
bpy.ops.gpencil.delete(type='POINTS')
# Delete selected points without splitting strokes
bpy.ops.gpencil.dissolve()
# Make annotations on the active data
bpy.ops.gpencil.draw(mode='DRAW', stroke=[], wait_for_input=True)
# Duplicate the selected Grease Pencil strokes
bpy.ops.gpencil.duplicate()
# Make copies of the selected Grease Pencil strokes and move them
bpy.ops.gpencil.duplicate_move(GPENCIL_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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})
# Enter/Exit edit mode for Grease Pencil strokes
bpy.ops.gpencil.editmode_toggle()
# Hide selected/unselected Grease Pencil layers
bpy.ops.gpencil.hide(unselected=False)
# Add new Grease Pencil layer for the active Grease Pencil datablock
bpy.ops.gpencil.layer_add()
# Change active Grease Pencil layer
bpy.ops.gpencil.layer_change(layer='DEFAULT')
# Make a copy of the active Grease Pencil layer
bpy.ops.gpencil.layer_duplicate()
# Toggle whether the active layer is the only one that can be edited and/or visible
bpy.ops.gpencil.layer_isolate(affect_visibility=False)
# Move the active Grease Pencil layer up/down in the list
bpy.ops.gpencil.layer_move(type='UP')
# Remove active Grease Pencil layer
bpy.ops.gpencil.layer_remove()
# Lock all Grease Pencil layers to prevent them from being accidentally modified
bpy.ops.gpencil.lock_all()
# Move selected strokes to another layer
bpy.ops.gpencil.move_to_layer(layer='DEFAULT')
# Paste previously copied strokes into active layer
bpy.ops.gpencil.paste()
# Show all Grease Pencil layers
bpy.ops.gpencil.reveal()
# Select Grease Pencil strokes and/or stroke points
bpy.ops.gpencil.select(extend=False, deselect=False, toggle=False, entire_strokes=False, location=(0, 0))
# Change selection of all Grease Pencil strokes currently visible
bpy.ops.gpencil.select_all(action='TOGGLE')
# Select Grease Pencil strokes within a rectangular region
bpy.ops.gpencil.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select Grease Pencil strokes using brush selection
bpy.ops.gpencil.select_circle(x=0, y=0, radius=1, gesture_mode=0)
# Select all strokes with similar characteristics
bpy.ops.gpencil.select_grouped(type='LAYER')
# Select Grease Pencil strokes using lasso selection
bpy.ops.gpencil.select_lasso(path=[], deselect=False, extend=True)
# Shrink sets of selected Grease Pencil points
bpy.ops.gpencil.select_less()
# Select all points in same strokes as already selected points
bpy.ops.gpencil.select_linked()
# Grow sets of selected Grease Pencil points
bpy.ops.gpencil.select_more()
# Snap cursor to center of selected points
bpy.ops.gpencil.snap_cursor_to_selected()
# Snap selected points/strokes to the cursor
bpy.ops.gpencil.snap_to_cursor(use_offset=True)
# Snap selected points to the nearest grid points
bpy.ops.gpencil.snap_to_grid()
# Unlock all Grease Pencil layers so that they can be edited
bpy.ops.gpencil.unlock_all()

# 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, channels=False)
# 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 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), "gpencil_strokes":False, "release_confirm":False})
# Set easing type for the F-Curve segments starting from the selected keyframes
bpy.ops.graph.easing_type(type='AUTO')
# 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')
# Hide selected curves from Graph Editor view
bpy.ops.graph.hide(unselected=False)
# 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', flipped=False)
# Automatically set Preview Range based on range of keyframes
bpy.ops.graph.previewrange_set()
# Toggle display properties panel
bpy.ops.graph.properties()
# Make previously hidden curves visible again in Graph Editor view
bpy.ops.graph.reveal()
# 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 keyframe points using circle selection
bpy.ops.graph.select_circle(x=0, y=0, radius=1, gesture_mode=0)
# Select all keyframes on the specified frame(s)
bpy.ops.graph.select_column(mode='KEYS')
# Select keyframe points using lasso selection
bpy.ops.graph.select_lasso(path=[], deselect=False, extend=True)
# 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, filter_blenlib=False, filemode=9, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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 range around current frame
bpy.ops.graph.view_frame()
# 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 a 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(group='<UNKNOWN ENUM>')
# Remove selected objects from all groups
bpy.ops.group.objects_remove_all()

# Interactively change the current frame number
bpy.ops.image.change_frame(frame=0)
# Clear the boundaries of the border render and disable border render
bpy.ops.image.clear_render_border()
# 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, gen_context='NONE', use_stereo_3d=False)
# Open image
bpy.ops.image.open(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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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()
# Read all the current scene's render layers from cache, as needed
bpy.ops.image.read_renderlayers()
# Reload current image from disk
bpy.ops.image.reload()
# Set the boundaries of the border render and enable border render
bpy.ops.image.render_border(xmin=0, xmax=0, ymin=0, ymax=0)
# 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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=1002)
# 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# Save all modified textures
bpy.ops.image.save_dirty()
# Save a sequence of images
bpy.ops.image.save_sequence()
# Toggles tool shelf display
bpy.ops.image.toolshelf()
# 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(fit_view=False)
# 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="", axis_forward='-Z', axis_up='Y', filter_glob="*.bvh", target='ARMATURE', global_scale=1, frame_start=1, use_fps_scale=False, update_scene_fps=False, update_scene_duration=False, use_cyclic=False, rotate_mode='NATIVE')

# 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="", axis_forward='Y', axis_up='Z', filter_glob="*.stl", files=[], directory="", global_scale=1, use_scene_unit=False, use_facet_normal=False)

# Import from 3DS file format (.3ds)
bpy.ops.import_scene.autodesk_3ds(filepath="", axis_forward='Y', axis_up='Z', filter_glob="*.3ds", constrain_size=10, use_image_search=True, use_apply_transform=True)
# Load a FBX file
bpy.ops.import_scene.fbx(filepath="", axis_forward='-Z', axis_up='Y', directory="", filter_glob="*.fbx", ui_tab='MAIN', use_manual_orientation=False, global_scale=1, bake_space_transform=False, use_custom_normals=True, use_image_search=True, use_alpha_decals=False, decal_offset=0, use_anim=True, anim_offset=1, use_custom_props=True, use_custom_props_enum_as_string=True, ignore_leaf_bones=False, force_connect_children=False, automatic_bone_orientation=False, primary_bone_axis='Y', secondary_bone_axis='X', use_prepost_rot=True)
# Load a Wavefront OBJ File
bpy.ops.import_scene.obj(filepath="", axis_forward='-Z', axis_up='Y', filter_glob="*.obj;*.mtl", 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)
# Import an X3D or VRML2 file
bpy.ops.import_scene.x3d(filepath="", axis_forward='Z', axis_up='Y', filter_glob="*.x3d;*.wrl")

# 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 or remove a Sky & Atmosphere Preset
bpy.ops.lamp.sunsky_preset_add(name="", remove_active=False)

# 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')
# Deselect vertices at the boundary of each selection region
bpy.ops.lattice.select_less()
# Select mirrored lattice points
bpy.ops.lattice.select_mirror(axis={'X'}, extend=False)
# Select vertex directly linked to already selected ones
bpy.ops.lattice.select_more()
# Randomly select UVW control points
bpy.ops.lattice.select_random(percent=50, seed=0, action='SELECT')
# 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="")
# 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 marker(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, "is_new_point":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)}, MASK_OT_slide_point={"slide_feather":False, "is_new_point":False})
# Copy selected splines to clipboard
bpy.ops.mask.copy_splines()
# Toggle cyclic for selected splines
bpy.ops.mask.cyclic_toggle()
# Delete selected control points or splines
bpy.ops.mask.delete()
# Duplicate selected control points and segments between them
bpy.ops.mask.duplicate()
# Duplicate mask and move
bpy.ops.mask.duplicate_move(MASK_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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})
# 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()
# Paste splines from clipboard
bpy.ops.mask.paste_splines()
# Add new circle-shaped spline
bpy.ops.mask.primitive_circle_add(size=100, location=(0, 0))
# Add new square-shaped spline
bpy.ops.mask.primitive_square_add(size=100, location=(0, 0))
# 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 curve points using border selection
bpy.ops.mask.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select curve points using circle selection
bpy.ops.mask.select_circle(x=0, y=0, radius=1, gesture_mode=0)
# Select curve points using lasso selection
bpy.ops.mask.select_lasso(path=[], deselect=False, extend=True)
# Deselect spline points at the boundary of each selection region
bpy.ops.mask.select_less()
# Select all curve points linked to already selected ones
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)
# Select more spline points connected to initial selection
bpy.ops.mask.select_more()
# 
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, is_new_point=False)
# Slide a point on the spline to define it's curvature
bpy.ops.mask.slide_spline_curvature()
# 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 or remove a Subsurface Scattering Preset
bpy.ops.material.sss_preset_add(name="", remove_active=False)

# Delete selected metaelement(s)
bpy.ops.mball.delete_metaelems()
# Duplicate selected metaelement(s)
bpy.ops.mball.duplicate_metaelems()
# Make copies of the selected metaelements and move them
bpy.ops.mball.duplicate_move(MBALL_OT_duplicate_metaelems={}, 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})
# 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=50, seed=0, action='SELECT')
# Select similar metaballs by property types
bpy.ops.mball.select_similar(type='TYPE', threshold=0.1)

# Rearrange some faces to try to get less degenerated geometry
bpy.ops.mesh.beautify_fill(angle_limit=3.14159)
# Edge Bevel
bpy.ops.mesh.bevel(offset_type='OFFSET', offset=0, segments=1, profile=0.5, vertex_only=False, clamp_overlap=False, loop_slide=True, material=-1)
# Cut geometry along a plane (click-drag to define plane)
bpy.ops.mesh.bisect(plane_co=(0, 0, 0), plane_no=(0, 0, 0), use_fill=False, clear_inner=False, clear_outer=False, threshold=0.0001, xstart=0, xend=0, ystart=0, yend=0, cursor=1002)
# 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, twist_offset=0, 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, face_threshold=0.698132, shape_threshold=0.698132, uvs=False, vcols=False, seam=False, sharp=False, materials=False)
# Add a custom split normals layer, if none exists yet
bpy.ops.mesh.customdata_custom_splitnormals_add()
# Remove the custom split normals layer, if it exists
bpy.ops.mesh.customdata_custom_splitnormals_clear()
# Clear vertex sculpt masking data from the mesh
bpy.ops.mesh.customdata_mask_clear()
# Add a vertex skin layer
bpy.ops.mesh.customdata_skin_add()
# Clear vertex skin layer
bpy.ops.mesh.customdata_skin_clear()
# 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)
# Delete loose vertices, edges or faces
bpy.ops.mesh.delete_loose(use_verts=True, use_edges=True, use_faces=False)
# Dissolve zero area faces and zero length edges
bpy.ops.mesh.dissolve_degenerate(threshold=0.0001)
# Dissolve edges, merging faces
bpy.ops.mesh.dissolve_edges(use_verts=True, use_face_split=False)
# Dissolve faces
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={'NORMAL'})
# Dissolve geometry based on the selection mode
bpy.ops.mesh.dissolve_mode(use_verts=False, use_face_split=False, use_boundary_tear=False)
# Dissolve verts, merge edges and faces
bpy.ops.mesh.dissolve_verts(use_face_split=False, use_boundary_tear=False)
# Assign Image to active UV Map, or create an UV Map
bpy.ops.mesh.drop_named_image(name="Image", filepath="Path", relative_path=True)
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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, "use_even_offset":True, "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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})
# Extrude region and move result
bpy.ops.mesh.extrude_region_shrink_fatten(MESH_OT_extrude_region={"mirror":False}, TRANSFORM_OT_shrink_fatten={"value":0, "use_even_offset":True, "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 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})
# Extrude individual vertices only
bpy.ops.mesh.extrude_verts_indiv(mirror=False)
# Flatten selected faces
bpy.ops.mesh.face_make_planar(factor=1, repeat=1)
# Weld loose edges into faces (splitting them into new faces)
bpy.ops.mesh.face_split_by_edges()
# 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(span=1, offset=0, use_interp_simple=False)
# Fill in holes (boundary edge loops)
bpy.ops.mesh.fill_holes(sides=4)
# 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, use_edge_rail=False, thickness=0.01, depth=0, use_outset=False, use_select_inset=False, use_individual=False, use_interpolate=True)
# Cut an intersection into faces
bpy.ops.mesh.intersect(mode='SELECT_UNSELECT', use_separate=True, threshold=1e-006)
# Cut solid geometry from selected to unselected
bpy.ops.mesh.intersect_boolean(operation='DIFFERENCE', use_swap=False, threshold=1e-006)
# Use other objects outlines & boundaries to project knife cuts
bpy.ops.mesh.knife_project(cut_through=False)
# 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='INVERSE_SQUARE', 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":'INVERSE_SQUARE', "edge_index":-1, "mesh_select_mode_init":(False, False, False)}, TRANSFORM_OT_edge_slide={"value":0, "single_side":False, "use_even":False, "flipped":False, "use_clamp":True, "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, use_verts=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)
# Create offset edge loop from the current selection
bpy.ops.mesh.offset_edge_loops(use_cap_endpoint=False)
# Offset edge loop slide
bpy.ops.mesh.offset_edge_loops_slide(MESH_OT_offset_edge_loops={"use_cap_endpoint":False}, TRANSFORM_OT_edge_slide={"value":0, "single_side":False, "use_even":False, "flipped":False, "use_clamp":True, "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})
# 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', calc_uvs=False, 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', calc_uvs=False, 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, calc_uvs=False, 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', calc_uvs=False, 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, calc_uvs=False, 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, calc_uvs=False, 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, calc_uvs=False, 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(location=(0, 0, 0), rotation=(0, 0, 0), view_align=False, layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False), major_segments=48, minor_segments=12, mode='MAJOR_MINOR', major_radius=1, minor_radius=0.25, abso_major_rad=1.25, abso_minor_rad=0.75)
# Construct a UV sphere mesh
bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=16, size=1, calc_uvs=False, 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(quad_method='BEAUTY', ngon_method='BEAUTY')
# 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)
# Extend vertices along the edge closest to the cursor
bpy.ops.mesh.rip_edge(mirror=False, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1, release_confirm=False)
# Extend vertices and move the result
bpy.ops.mesh.rip_edge_move(MESH_OT_rip_edge={"mirror":False, "proportional":'DISABLED', "proportional_edit_falloff":'SMOOTH', "proportional_size":1, "release_confirm":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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', threshold=0.0001)
# 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(use_face_step=True)
# Select all vertices linked to the active mesh
bpy.ops.mesh.select_linked(delimit={'SEAM'})
# (De)select all vertices linked to the edge under the mouse cursor
bpy.ops.mesh.select_linked_pick(deselect=False, delimit={'SEAM'}, index=-1)
# 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(axis={'X'}, 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(use_face_step=True)
# Select the next element (using selection order)
bpy.ops.mesh.select_next_item()
# Select all non-manifold vertices or edges
bpy.ops.mesh.select_non_manifold(extend=True, use_wire=True, use_boundary=True, use_multi_face=True, use_non_contiguous=True, use_verts=True)
# Deselect every Nth element starting from the active vertex, edge or face
bpy.ops.mesh.select_nth(nth=2, skip=1, offset=0)
# Select the next element (using selection order)
bpy.ops.mesh.select_prev_item()
# Randomly select vertices
bpy.ops.mesh.select_random(percent=50, seed=0, action='SELECT')
# Select similar vertices, edges or faces by property types
bpy.ops.mesh.select_similar(type='NORMAL', compare='EQUAL', threshold=0)
# Select similar face regions to the current selection
bpy.ops.mesh.select_similar_region()
# 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(use_face_step=False, use_topology_distance=False, nth=1, skip=1, offset=0, index=-1)
# Selected vertex path between two vertices
bpy.ops.mesh.shortest_path_select(use_face_step=False, use_topology_distance=False, nth=1, skip=1, offset=0)
# 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={'VERT'}, 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', threshold=0.0001)
# 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(face_threshold=0.698132, shape_threshold=0.698132, uvs=False, vcols=False, seam=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 selected vertices of faces, splitting the face
bpy.ops.mesh.vert_connect()
# Make all faces convex
bpy.ops.mesh.vert_connect_concave()
# Split non-planar faces that exceed the angle threshold
bpy.ops.mesh.vert_connect_nonplanar(angle_limit=0.0872665)
# Connect vertices by their selection order, creating edges, splitting faces
bpy.ops.mesh.vert_connect_path()
# 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(factor=0.5, repeat=1, xaxis=True, yaxis=True, zaxis=True)
# Laplacian smooth of selected vertices
bpy.ops.mesh.vertices_smooth_laplacian(repeat=1, lambda_factor=5e-005, lambda_border=5e-005, use_x=True, use_y=True, use_z=True, preserve_volume=True)
# Create a solid wire-frame from faces
bpy.ops.mesh.wireframe(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_replace=True, thickness=0.01, offset=0.01, use_crease=False, crease_weight=0.01)

# Push action down onto the top of the NLA stack as a new strip
bpy.ops.nla.action_pushdown(channel_index=-1)
# Synchronize the length of the referenced Action with the length used in the strip
bpy.ops.nla.action_sync_length(active=True)
# Unlink this action from the active action slot (and/or exit Tweak Mode)
bpy.ops.nla.action_unlink(force_delete=False)
# 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, visual_keying=False, clear_constraints=False, clear_parents=False, use_current_action=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(linked=False, 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()
# Ensure that each action is only used once in the set of strips selected
bpy.ops.nla.make_single_user()
# 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()
# Automatically set Preview Range based on range of keyframes
bpy.ops.nla.previewrange_set()
# 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 to edit its keyframes
bpy.ops.nla.tweakmode_enter(isolate_action=False)
# Exit tweaking mode for the action referenced by the active strip
bpy.ops.nla.tweakmode_exit(isolate_action=False)
# 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(settings=[], type="", use_transform=False, 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=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', name="Image")
# Add a mask node to the current node editor
bpy.ops.node.add_mask(name="Mask")
# Add a node to the active tree
bpy.ops.node.add_node(settings=[], type="", use_transform=False)
# Add a reroute node
bpy.ops.node.add_reroute(path=[], cursor=6)
# Add a node to the active tree
bpy.ops.node.add_search(settings=[], type="", use_transform=False, node_item='<UNKNOWN ENUM>')
# Attach active node to a frame
bpy.ops.node.attach()
# Fit the background image to the view
bpy.ops.node.backimage_fit()
# 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)
# Clear the boundaries for viewer operations
bpy.ops.node.clear_viewer_border()
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False}, "NODE_OT_attach":{}, "NODE_OT_insert_offset":{}})
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False}, "NODE_OT_attach":{}, "NODE_OT_insert_offset":{}})
# 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()
# Automatically offset nodes on insertion
bpy.ops.node.insert_offset()
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False}, NODE_OT_insert_offset={})
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False}, "NODE_OT_attach":{}, "NODE_OT_insert_offset":{}})
# Toggle muting of the nodes
bpy.ops.node.mute_toggle()
# Create a new node tree
bpy.ops.node.new_node_tree(type='ShaderNodeTree', name="NodeTree")
# Add or remove a Node Color Preset
bpy.ops.node.node_color_preset_add(name="", remove_active=False)
# 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()
# 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)
# Use circle selection to select nodes
bpy.ops.node.select_circle(x=0, y=0, radius=1, gesture_mode=0)
# Select nodes with similar properties
bpy.ops.node.select_grouped(extend=False, type='TYPE')
# 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()
# 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()
# Update views of selected node
bpy.ops.node.switch_view_update()
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False}, NODE_OT_attach={}, NODE_OT_insert_offset={})
# Move nodes and attach to frame
bpy.ops.node.translate_attach_remove_on_cancel(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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False}, NODE_OT_attach={}, NODE_OT_insert_offset={})
# 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(radius=1, 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="")
# 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(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))
# Bake image textures of selected objects
bpy.ops.object.bake(type='COMBINED', pass_filter=set(), filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage_object="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_cage=False, use_split_materials=False, use_automatic_name=False, uv_layer="")
# 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)
# Bind base pose in Corrective Smooth modifier
bpy.ops.object.correctivesmooth_bind(modifier="")
# Transfer data layer(s) (weights, edge sharp, ...) from active to selected meshes
bpy.ops.object.data_transfer(use_reverse_transfer=False, use_freeze=False, data_type='<UNKNOWN ENUM>', use_create=True, vert_mapping='NEAREST', edge_mapping='NEAREST', loop_mapping='NEAREST_POLYNOR', poly_mapping='NEAREST', use_auto_transform=False, use_object_transform=True, use_max_distance=False, max_distance=1, ray_radius=0, islands_precision=0.1, layers_select_src='ACTIVE', layers_select_dst='ACTIVE', mix_mode='REPLACE', mix_factor=1)
# Transfer layout of data layer(s) from active to selected meshes
bpy.ops.object.datalayout_transfer(modifier="", data_type='<UNKNOWN ENUM>', use_delete=False, layers_select_src='ACTIVE', layers_select_dst='ACTIVE')
# 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="", relative_path=True, 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()
# 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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":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', 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 an empty object to the scene
bpy.ops.object.empty_add(type='PLAIN_AXES', radius=1, 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>')
# Move game property
bpy.ops.object.game_property_move(index=0, direction='UP')
# 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()
# Unlink the group from all objects
bpy.ops.object.group_unlink()
# Select all objects in group
bpy.ops.object.grouped_select()
# 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 a newly created 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 Maps 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', radius=1, 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))
# Bind mesh to system in laplacian deform modifier
bpy.ops.object.laplaciandeform_bind(modifier="")
# Clear the object's location
bpy.ops.object.location_clear()
# Add a level of detail to this object
bpy.ops.object.lod_add()
# Add levels of detail to this object based on object names
bpy.ops.object.lod_by_name()
# Remove all levels of detail from this object
bpy.ops.object.lod_clear_all()
# Generate levels of detail using the decimate modifier
bpy.ops.object.lod_generate(count=3, target=0.1, package=False)
# Remove a level of detail from this object
bpy.ops.object.lod_remove(index=1)
# Copy logic bricks to other selected objects
bpy.ops.object.logic_bricks_copy()
# Convert objects into dupli-face instanced
bpy.ops.object.make_dupli_face()
# Apply active object links 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()
# Move the active material up/down in the list
bpy.ops.object.material_slot_move(direction='UP')
# 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', 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))
# 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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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 all objects, hold Shift key for selected objects only
bpy.ops.object.paths_clear(only_selected=False)
# 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='SMOKE', 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)
# Deselect objects at the boundaries of parent/child relationships
bpy.ops.object.select_less()
# 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 connected parent/child objects
bpy.ops.object.select_more()
# 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, seed=0, action='SELECT')
# 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='TOP')
# 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(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))
# Clear tracking constraint or flag from object
bpy.ops.object.track_clear(type='CLEAR')
# Make the object track another object, using various methods/constraints
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)
# 
bpy.ops.object.unlink_data()
# 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()
# Remove vertex group assignments which are not 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()
# Replace vertex groups of all users of the same geometry data by vertex groups of active object
bpy.ops.object.vertex_group_copy_to_linked()
# Replace vertex groups of selected objects by vertex groups of active object
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 vertex group, 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(group_select_mode='ALL', lock_active=True)
# Set weights to a fixed number of steps
bpy.ops.object.vertex_group_quantize(group_select_mode='ACTIVE', steps=4)
# Delete the active or all vertex groups from the active object
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>')
# Smooth weights for selected vertices
bpy.ops.object.vertex_group_smooth(group_select_mode='ACTIVE', factor=0.5, repeat=1, expand=0, source='ALL')
# Sort vertex groups
bpy.ops.object.vertex_group_sort(sort_type='NAME')
# 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 vertex's 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='CLEAR_ANIMDATA')
# 
bpy.ops.outliner.constraint_operation(type='ENABLE')
# 
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()
# Link Object to Group in Outliner
bpy.ops.outliner.group_link(object="Object")
# 
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()
# Delete the library under cursor (needs a save/reload)
bpy.ops.outliner.lib_delete()
# 
bpy.ops.outliner.lib_operation(type='RENAME')
# Drag material to object in Outliner
bpy.ops.outliner.material_drop(object="Object", material="Material")
# 
bpy.ops.outliner.modifier_operation(type='TOGVIS')
# 
bpy.ops.outliner.object_operation(type='SELECT')
# Context menu for item operations
bpy.ops.outliner.operation()
# Clear all orphaned datablocks without any users from the file (cannot be undone)
bpy.ops.outliner.orphans_purge()
# 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")
# Context menu for scene operations
bpy.ops.outliner.scene_operation(type='DELETE')
# 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()
# Open up the tree and 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()

# Add cube map uvs on mesh
bpy.ops.paint.add_simple_uvs()
# Add a texture paint slot
bpy.ops.paint.add_texture_paint_slot(type='DIFFUSE_COLOR', name="Untitled", width=1024, height=1024, color=(0, 0, 0, 1), alpha=True, generated_type='BLANK', float=False)
# Toggle foreground and background brush colors
bpy.ops.paint.brush_colors_flip()
# 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)
# Delete selected texture paint slot
bpy.ops.paint.delete_texture_paint_slot()
# 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 under the cursor
bpy.ops.paint.face_select_linked_pick(deselect=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(stroke=[], mode='NORMAL')
# Fill the whole mask with a given value, or invert its values
bpy.ops.paint.mask_flood_fill(mode='VALUE', value=0)
# Add mask within the lasso as you move the brush
bpy.ops.paint.mask_lasso_gesture(path=[], mode='VALUE', value=1)
# 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), merged=False, palette=False)
# 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=[], mode='NORMAL')
# 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')
# Draw a line to apply a weight gradient to selected vertices
bpy.ops.paint.weight_gradient(type='LINEAR', xstart=0, xend=0, ystart=0, yend=0, cursor=1002)
# Paint a stroke in the current vertex group's weights
bpy.ops.paint.weight_paint(stroke=[], mode='NORMAL')
# 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()

# Add New Paint Curve Point
bpy.ops.paintcurve.add_point(location=(0, 0))
# Add new curve point and slide it
bpy.ops.paintcurve.add_point_slide(PAINTCURVE_OT_add_point={"location":(0, 0)}, PAINTCURVE_OT_slide={"align":False, "select":True})
# Place cursor
bpy.ops.paintcurve.cursor()
# Remove Paint Curve Point
bpy.ops.paintcurve.delete_point()
# Draw curve
bpy.ops.paintcurve.draw()
# Add new paint curve
bpy.ops.paintcurve.new()
# Select a paint curve point
bpy.ops.paintcurve.select(location=(0, 0), toggle=False, extend=False)
# Select and slide paint curve point
bpy.ops.paintcurve.slide(align=False, select=True)

# Add new color to active palette
bpy.ops.palette.color_add()
# Remove active color from palette
bpy.ops.palette.color_delete()
# Add new palette
bpy.ops.palette.new()

# 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)
# Copy particle systems from the active object to selected objects
bpy.ops.particle.copy_particle_systems(space='OBJECT', remove_target_particles=True, use_active=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()
# Add or remove a Hair Dynamics Preset
bpy.ops.particle.hair_dynamics_preset_add(name="", remove_active=False)
# 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 a randomly distributed set of hair or points
bpy.ops.particle.select_random(percent=50, seed=0, action='SELECT', type='HAIR')
# 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')
# Cut hair to conform to the set shape object
bpy.ops.particle.shape_cut()
# 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()
# 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 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 all bones, hold Shift key for selected bones only
bpy.ops.pose.paths_clear(only_selected=False)
# 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()
# 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)
# Mirror the bone selection
bpy.ops.pose.select_mirror(only_active=False, 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(name="", remove_active=False)
# Add a Sampling Preset
bpy.ops.render.cycles_sampling_preset_add(name="", remove_active=False)
# 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 or remove a Render Preset
bpy.ops.render.preset_add(name="", remove_active=False)
# Render active scene
bpy.ops.render.render(animation=False, write_still=False, use_viewport=False, layer="", scene="")
# Set shutter curve
bpy.ops.render.shutter_curve_preset(shape='SMOOTH')
# 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()

# Add or remove a Safe Areas Preset
bpy.ops.safe_areas.preset_add(name="", remove_active=False)

# 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()
# Create Freestyle stroke material for testing
bpy.ops.scene.freestyle_stroke_material_create()
# 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()
# Add a render view
bpy.ops.scene.render_view_add()
# Remove the selected render view
bpy.ops.scene.render_view_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 header display
bpy.ops.screen.header()
# Toggle the header over/below the main window area
bpy.ops.screen.header_flip()
# Expand or collapse 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)
# Jump to previous/next marker
bpy.ops.screen.marker_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/maximized
bpy.ops.screen.screen_full_area(use_hide_panels=False)
# 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, filter_blenlib=False, filemode=9, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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)
# Flood fill the mesh with the selected detail setting
bpy.ops.sculpt.detail_flood_fill()
# 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()
# Sample the mesh detail on clicked point
bpy.ops.sculpt.sample_detail_size(location=(0, 0))
# Toggle sculpt mode in 3D view
bpy.ops.sculpt.sculptmode_toggle()
# Set the mesh detail (either relative or constant one, depending on current dyntopo mode)
bpy.ops.sculpt.set_detail_size()
# 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=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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', use_placeholders=False)
# 
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_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})
# 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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', frame_start=0, frame_end=0, channel=1, replace_sel=True, overlap=False, type='CROSS', color=(0, 0, 0))
# Enable selected proxies on all selected Movie strips
bpy.ops.sequencer.enable_proxies(proxy_25=False, proxy_50=False, proxy_75=False, proxy_100=False, override=False)
# Export .srt file containing text strips
bpy.ops.sequencer.export_subtitles(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=False, filter_folder=True, filter_blenlib=False, filemode=8, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', frame_start=0, frame_end=0, channel=1, replace_sel=True, overlap=False, use_placeholders=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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', frame_start=0, channel=1, replace_sel=True, overlap=False, sound=True, use_framerate=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 (un)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='NONE', 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')
# Select strips using border selection
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()
# Trim the contents of the active strip
bpy.ops.sequencer.slip(offset=0)
# 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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', frame_start=0, channel=1, replace_sel=True, overlap=False, cache=False, mono=False)
# Move frame to previous edit point
bpy.ops.sequencer.strip_jump(next=True, center=True)
# Add a modifier to the strip
bpy.ops.sequencer.strip_modifier_add(type='COLOR_BALANCE')
# Copy modifiers of the active strip to all selected strips
bpy.ops.sequencer.strip_modifier_copy(type='REPLACE')
# Move modifier up and down in the stack
bpy.ops.sequencer.strip_modifier_move(name="Name", direction='UP')
# Remove a modifier from the 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()
# Unmute (un)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()
# Set the boundaries of the border used for offset-view
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, filter_blenlib=False, filemode=9, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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(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 Nurbs surface Curve
bpy.ops.surface.primitive_nurbs_surface_curve_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 Nurbs surface Cylinder
bpy.ops.surface.primitive_nurbs_surface_cylinder_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 Nurbs surface Sphere
bpy.ops.surface.primitive_nurbs_surface_sphere_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 Nurbs surface Patch
bpy.ops.surface.primitive_nurbs_surface_surface_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 Nurbs surface Torus
bpy.ops.surface.primitive_nurbs_surface_torus_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))

# 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')
# Move the cursor while selecting
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, filter_blenlib=False, filemode=9, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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, filter_blenlib=False, filemode=9, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 
bpy.ops.text.scroll(lines=1)
# 
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, filter_blenlib=False, filemode=9, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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()

# Bend selected items between the 3D cursor and the mouse
bpy.ops.transform.bend(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), gpencil_strokes=False, release_confirm=False)
# 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, single_side=False, use_even=False, flipped=False, use_clamp=True, 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 items 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, gpencil_strokes=False, 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), gpencil_strokes=False, texture_space=False, remove_on_cancel=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), gpencil_strokes=False, 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), gpencil_strokes=False, release_confirm=False)
# Shrink/fatten selected vertices along normals
bpy.ops.transform.shrink_fatten(value=0, use_even_offset=True, 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), 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), gpencil_strokes=False, 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), gpencil_strokes=False, 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), gpencil_strokes=False, 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), gpencil_strokes=False, texture_space=False, remove_on_cancel=False, release_confirm=False)
# Slide a vertex along a mesh
bpy.ops.transform.vert_slide(value=0, use_even=False, flipped=False, use_clamp=True, 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)
# Randomize vertices
bpy.ops.transform.vertex_random(offset=0.1, uniform=0, normal=0, seed=0)
# Warp vertices around the cursor
bpy.ops.transform.vertex_warp(warp_angle=6.28319, offset_angle=0, min=-1, max=1, viewmat=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), center=(0, 0, 0))

# Copy the RNA data path for this property to the clipboard
bpy.ops.ui.copy_data_path_button()
# Copy the Python command matching this button
bpy.ops.ui.copy_python_command_button()
# Copy property from this object to selected objects or bones
bpy.ops.ui.copy_to_selected_button(all=True)
# Drop colors to buttons
bpy.ops.ui.drop_color(color=(0, 0, 0), gamma=False)
# 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 data-block from the 3D view
bpy.ops.ui.eyedropper_color()
# Sample depth from the 3D view
bpy.ops.ui.eyedropper_depth()
# Sample a datablock from the Blender Window to store in a property
bpy.ops.ui.eyedropper_id()
# 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()
# Clear the property and use default or generated value in operators
bpy.ops.ui.unset_property_button()

# 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=1, 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)
# Pack each faces UV's into the UV bounds
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(clear=False)
# 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(rotate=True, 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, use_aspect=True, stretch_to_bounds=True)
# 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()

# Use a 3D mouse device to pan/zoom the view
bpy.ops.view2d.ndof()
# 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()
# 
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="", 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, filter_blenlib=False, filemode=9, relative_path=True, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA')
# 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()
# Extrude and move along individual normals
bpy.ops.view3d.edit_mesh_extrude_move_shrink_fatten()
# 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()
# Interactively navigate around the scene (uses the mode (walk/fly) preference)
bpy.ops.view3d.navigate()
# Pan and rotate the view with the 3D mouse
bpy.ops.view3d.ndof_all()
# Orbit the view using the 3D mouse
bpy.ops.view3d.ndof_orbit()
# Orbit and zoom the view using the 3D mouse
bpy.ops.view3d.ndof_orbit_zoom()
# Pan the view 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(autoselect=True, active_layer=True)
# 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=1, 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)
# 
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 division
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(use_offset=True)
# Snap selected item(s) to nearest grid division
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 lock offset
bpy.ops.view3d.view_center_lock()
# 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(angle=0, 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()
# Roll the view
bpy.ops.view3d.view_roll(angle=0, type='ANGLE')
# 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='LEFT', align_active=False)
# Interactively walk around the scene
bpy.ops.view3d.walk()
# 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 add-on
bpy.ops.wm.addon_disable(module="")
# Enable an add-on
bpy.ops.wm.addon_enable(module="")
# Display information and preferences for this add-on
bpy.ops.wm.addon_expand(module="")
# Install an add-on
bpy.ops.wm.addon_install(overwrite=True, target='DEFAULT', filepath="", filter_folder=True, filter_python=True, filter_glob="*.py;*.zip")
# Scan add-on directories for new modules
bpy.ops.wm.addon_refresh()
# Delete the add-on from the file system
bpy.ops.wm.addon_remove(module="")
# 
bpy.ops.wm.appconfig_activate(filepath="")
# 
bpy.ops.wm.appconfig_default()
# Append from a Library .blend file
bpy.ops.wm.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, filter_blenlib=True, filemode=1, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', link=False, autoselect=True, active_layer=True, instance_groups=False, set_fake=False)
# 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="")
# Call (draw) a pre-defined pie menu
bpy.ops.wm.call_menu_pie(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, filter_blenlib=False, filemode=8, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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', open_sim=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, filter_blenlib=False, filemode=8, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', import_units=False, fix_orientation=False, find_chains=False, min_chain_length=0)
# Toggle System Console
bpy.ops.wm.console_toggle()
# 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, wrap=False)
# Set a context value (useful for cycling active material, vertex keys, groups, etc.)
bpy.ops.wm.context_cycle_int(data_path="", reverse=False, wrap=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)
# 
bpy.ops.wm.context_pie_enum(data_path="")
# Scale a float context value
bpy.ops.wm.context_scale_float(data_path="", value=1)
# 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)
# Set a context value to an ID data-block
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_view(doc_id="")
# Load online manual
bpy.ops.wm.doc_view_manual(doc_id="")
# View a context based online manual in a web browser
bpy.ops.wm.doc_view_manual_ui_context()
# Add or remove an Application Interaction Preset
bpy.ops.wm.interaction_preset_add(name="", remove_active=False)
# Add or remove a theme preset
bpy.ops.wm.interface_theme_preset_add(name="", remove_active=False)
# 
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 or remove a Key-config Preset
bpy.ops.wm.keyconfig_preset_add(name="", remove_active=False)
# 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 from a Library .blend file
bpy.ops.wm.link(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, filter_blenlib=True, filemode=1, relative_path=True, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', link=True, autoselect=True, active_layer=True, instance_groups=True)
# Print memory statistics to the console
bpy.ops.wm.memory_statistics()
# 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, filter_blenlib=False, filemode=8, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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()
# 
bpy.ops.wm.operator_pie_enum(data_path="", prop_string="")
# Add or remove an Operator Preset
bpy.ops.wm.operator_preset_add(name="", remove_active=False, operator="")
# Open a path in a file browser
bpy.ops.wm.path_open(filepath="")
# Clear selected .blend file's previews
bpy.ops.wm.previews_batch_clear(files=[], directory="", filter_blender=True, filter_folder=True, use_scenes=True, use_groups=True, use_objects=True, use_intern_data=True, use_trusted=False)
# Generate selected .blend file's previews
bpy.ops.wm.previews_batch_generate(files=[], directory="", filter_blender=True, filter_folder=True, use_scenes=True, use_groups=True, use_objects=True, use_intern_data=True, use_trusted=False)
# Clear datablock previews (only for some types like objects, materials, textures, etc.)
bpy.ops.wm.previews_clear(id_type={'SCENE', 'GROUP', 'OBJECT', 'MATERIAL', 'LAMP', 'WORLD', 'TEXTURE', 'IMAGE'})
# Ensure datablock previews are available and up-to-date (to be saved in .blend file, only for some types like materials, textures, etc.)
bpy.ops.wm.previews_ensure()
# 
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=-10000, max=10000, use_soft_limits=False, soft_min=-10000, soft_max=10000, 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="", fill_color_override_path="", fill_color_override_test_path="", zoom_path="", image_id="", secondary_tex=False)
# 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(filepath="", load_ui=True)
# 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, filter_blenlib=False, filemode=8, display_type='LIST_LONG', sort_method='FILE_SORT_TIME')
# 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, time_limit=0)
# Reload the saved file
bpy.ops.wm.revert_mainfile(use_scripts=True)
# 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, filter_blenlib=False, filemode=8, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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, filter_blenlib=False, filemode=8, display_type='DEFAULT', sort_method='FILE_SORT_ALPHA', 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()
# Toggle 3D stereo support for current window (or change the display mode)
bpy.ops.wm.set_stereo_3d(display_mode='ANAGLYPH', anaglyph_type='RED_CYAN', interlace_type='ROW_INTERLEAVED', use_interlace_swap=False, use_sidebyside_crosseyed=False)
# Open the splash screen with release info
bpy.ops.wm.splash()
# Generate system information, saved into a text file
bpy.ops.wm.sysinfo(filepath="")
# 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="")
# Add path to exclude from autoexecution
bpy.ops.wm.userpref_autoexec_path_add()
# Remove path to exclude from autoexecution
bpy.ops.wm.userpref_autoexec_path_remove(index=0)
# Close the current Blender window
bpy.ops.wm.window_close()
# 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()
</code>
Dan's Wiki

User Tools

Site Tools

Page Tools
