.. _operatorlist:

=============
Operator list
=============

.. index:: Operator list

.. |a| image:: /images/all/appendix/operatorlist-100.png

Objectives
==========
   
.. tabularcolumns:: | c | l |
   :border: none

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

Instructions
============
:Tasks:
1. Select the menu *Help » Operator Cheat Sheet*
2. Switch the text file  and search for » mesh.primitive_ «


Call the menu
=============

.. image:: /images/all/appendix/list_of_operators.png
   :width: 550px


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

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

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

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

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

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

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

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

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

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

| # Add a Cloth Preset
| bpy.ops.cloth.preset_add(remove_active=False, name="")

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

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

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

| # Enable nodes on a material, world or lamp
| bpy.ops.cycles.use_shading_nodes()

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

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

| # Save a BVH motion capture file from an armature
| bpy.ops.export_anim.bvh(check_existing=True, filepath="", filter_glob="*.bvh", global_scale=1, frame_start=0, frame_end=0, rotate_mode='NATIVE', root_transform_only=False)

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

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

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

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

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

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

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

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

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

| # Load a BVH motion capture file
| bpy.ops.import_anim.bvh(filepath="", filter_glob="*.bvh", target='ARMATURE', global_scale=1, frame_start=1, use_fps_scale=False, use_cyclic=False, rotate_mode='NATIVE', axis_forward='-Z', axis_up='Y')

| # Load a SVG file
| bpy.ops.import_curve.svg(filepath="", filter_glob="*.svg")

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

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

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

| # Add a Sky & Atmosphere Preset
| bpy.ops.lamp.sunsky_preset_add(remove_active=False, name="")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

| # Add a new world
| bpy.ops.world.new()