Graph Operators

bpy.ops.graph.bake_keys()

Add keyframes on every frame between the selected keyframes

bpy.ops.graph.blend_offset(*, factor=0.0)

Shift selected keys to the value of the neighboring keys as a block

Parameters:

factor (float in [-inf, inf], (optional)) – Offset Factor, Control which key to offset towards and how far

bpy.ops.graph.blend_to_default(*, factor=0.0)

Blend selected keys to their default value from their current position

Parameters:

factor (float in [-inf, inf], (optional)) – Factor, How much to blend to the default value

bpy.ops.graph.blend_to_ease(*, factor=0.0)

Blends keyframes from current state to an ease-in or ease-out curve

Parameters:

factor (float in [-inf, inf], (optional)) – Blend, Favor either original data or ease curve

bpy.ops.graph.blend_to_neighbor(*, factor=0.0)

Blend selected keyframes to their left or right neighbor

Parameters:

factor (float in [-inf, inf], (optional)) – Blend, The blend factor with 0 being the current frame

bpy.ops.graph.breakdown(*, factor=0.0)

Move selected keyframes to an inbetween position relative to adjacent keys

Parameters:

factor (float in [-inf, inf], (optional)) – Factor, Favor either the left or the right key

bpy.ops.graph.butterworth_smooth(*, cutoff_frequency=3.0, filter_order=4, samples_per_frame=1, blend=1.0, blend_in_out=1)

Smooth an F-Curve while maintaining the general shape of the curve

Parameters:

  • cutoff_frequency (float in [0, inf], (optional)) – Frequency Cutoff (Hz), Lower values give a smoother curve

  • filter_order (int in [1, 32], (optional)) – Filter Order, Higher values produce a harder frequency cutoff

  • samples_per_frame (int in [1, 64], (optional)) – Samples per Frame, How many samples to calculate per frame, helps with subframe data

  • blend (float in [0, inf], (optional)) – Blend, How much to blend to the smoothed curve

  • blend_in_out (int in [0, inf], (optional)) – Blend In/Out, Linearly blend the smooth data to the border frames of the selection

bpy.ops.graph.clean(*, threshold=0.001, channels=False)

Simplify F-Curves by removing closely spaced keyframes

Parameters:

  • threshold (float in [0, inf], (optional)) – Threshold

  • channels (boolean, (optional)) – Channels

bpy.ops.graph.click_insert(*, frame=1.0, value=1.0, extend=False)

Insert new keyframe at the cursor position for the active F-Curve

Parameters:

  • frame (float in [-inf, inf], (optional)) – Frame Number, Frame to insert keyframe on

  • value (float in [-inf, inf], (optional)) – Value, Value for keyframe on

  • extend (boolean, (optional)) – Extend, Extend selection instead of deselecting everything first

bpy.ops.graph.clickselect(*, wait_to_deselect_others=False, mouse_x=0, mouse_y=0, extend=False, deselect_all=False, column=False, curves=False)

Select keyframes by clicking on them

Parameters:

  • wait_to_deselect_others (boolean, (optional)) – Wait to Deselect Others

  • mouse_x (int in [-inf, inf], (optional)) – Mouse X

  • mouse_y (int in [-inf, inf], (optional)) – Mouse Y

  • extend (boolean, (optional)) – Extend Select, Toggle keyframe selection instead of leaving newly selected keyframes only

  • deselect_all (boolean, (optional)) – Deselect On Nothing, Deselect all when nothing under the cursor

  • column (boolean, (optional)) – Column Select, Select all keyframes that occur on the same frame as the one under the mouse

  • curves (boolean, (optional)) – Only Curves, Select all the keyframes in the curve

bpy.ops.graph.copy()

Copy selected keyframes to the internal clipboard

bpy.ops.graph.cursor_set(*, frame=0.0, value=0.0)

Interactively set the current frame and value cursor

Parameters:

  • frame (float in [-1.04857e+06, 1.04857e+06], (optional)) – Frame

  • value (float in [-inf, inf], (optional)) – Value

bpy.ops.graph.decimate(*, mode='RATIO', factor=0.333333, remove_error_margin=0.0)

Decimate F-Curves by removing keyframes that influence the curve shape the least

Parameters:

  • mode (enum in ['RATIO', 'ERROR'], (optional)) –

    Mode, Which mode to use for decimation

    • RATIO Ratio – Use a percentage to specify how many keyframes you want to remove.

    • ERROR Error Margin – Use an error margin to specify how much the curve is allowed to deviate from the original path.

  • factor (float in [0, 1], (optional)) – Factor, The ratio of keyframes to remove

  • remove_error_margin (float in [0, inf], (optional)) – Max Error Margin, How much the new decimated curve is allowed to deviate from the original

bpy.ops.graph.delete(*, confirm=True)

Remove all selected keyframes

Parameters:

confirm (boolean, (optional)) – Confirm, Prompt for confirmation

bpy.ops.graph.driver_delete_invalid()

Delete all visible drivers considered invalid

bpy.ops.graph.driver_variables_copy()

Copy the driver variables of the active driver

bpy.ops.graph.driver_variables_paste(*, replace=False)

Add copied driver variables to the active driver

Parameters:

replace (boolean, (optional)) – Replace Existing, Replace existing driver variables, instead of just appending to the end of the existing list

bpy.ops.graph.duplicate(*, mode='TRANSLATION')

Make a copy of all selected keyframes

Parameters:

mode (enum in Transform Mode Type Items, (optional)) – Mode

bpy.ops.graph.duplicate_move(*, GRAPH_OT_duplicate=None, TRANSFORM_OT_translate=None)

Make a copy of all selected keyframes and move them

Parameters:

  • GRAPH_OT_duplicate (GRAPH_OT_duplicate, (optional)) – Duplicate Keyframes, Make a copy of all selected keyframes

  • TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.graph.ease(*, factor=0.0, sharpness=2.0)

Align keyframes on a ease-in or ease-out curve

Parameters:

  • factor (float in [-inf, inf], (optional)) – Curve Bend, Defines if the keys should be aligned on an ease-in or ease-out curve

  • sharpness (float in [0.001, inf], (optional)) – Sharpness, Higher values make the change more abrupt

bpy.ops.graph.easing_type(*, type='AUTO')

Set easing type for the F-Curve segments starting from the selected keyframes

Parameters:

type (enum in Beztriple Interpolation Easing Items, (optional)) – Type

bpy.ops.graph.equalize_handles(*, side='LEFT', handle_length=5.0, flatten=False)

Ensure selected keyframes’ handles have equal length, optionally making them horizontal. Automatic, Automatic Clamped, or Vector handle types will be converted to Aligned

Parameters:

  • side (enum in ['LEFT', 'RIGHT', 'BOTH'], (optional)) –

    Side, Side of the keyframes’ Bézier handles to affect

    • LEFT Left – Equalize selected keyframes’ left handles.

    • RIGHT Right – Equalize selected keyframes’ right handles.

    • BOTH Both – Equalize both of a keyframe’s handles.

  • handle_length (float in [0.1, inf], (optional)) – Handle Length, Length to make selected keyframes’ Bézier handles

  • flatten (boolean, (optional)) – Flatten, Make the values of the selected keyframes’ handles the same as their respective keyframes

bpy.ops.graph.euler_filter()

Fix large jumps and flips in the selected Euler Rotation F-Curves arising from rotation values being clipped when baking physics

bpy.ops.graph.extrapolation_type(*, type='CONSTANT')

Set extrapolation mode for selected F-Curves

Parameters:

type (enum in ['CONSTANT', 'LINEAR', 'MAKE_CYCLIC', 'CLEAR_CYCLIC'], (optional)) –

Type

  • CONSTANT Constant Extrapolation – Values on endpoint keyframes are held.

  • LINEAR Linear Extrapolation – Straight-line slope of end segments are extended past the endpoint keyframes.

  • MAKE_CYCLIC Make Cyclic (F-Modifier) – Add Cycles F-Modifier if one doesn’t exist already.

  • CLEAR_CYCLIC Clear Cyclic (F-Modifier) – Remove Cycles F-Modifier if not needed anymore.

bpy.ops.graph.fmodifier_add(*, type='NULL', only_active=False)

Add F-Modifier to the active/selected F-Curves

Parameters:

  • type (enum in Fmodifier Type Items, (optional)) – Type

  • only_active (boolean, (optional)) – Only Active, Only add F-Modifier to active F-Curve

bpy.ops.graph.fmodifier_copy()

Copy the F-Modifier(s) of the active F-Curve

bpy.ops.graph.fmodifier_paste(*, only_active=False, replace=False)

Add copied F-Modifiers to the selected F-Curves

Parameters:

  • only_active (boolean, (optional)) – Only Active, Only paste F-Modifiers on active F-Curve

  • replace (boolean, (optional)) – Replace Existing, Replace existing F-Modifiers, instead of just appending to the end of the existing list

bpy.ops.graph.frame_jump()

Place the cursor on the midpoint of selected keyframes

bpy.ops.graph.gaussian_smooth(*, factor=1.0, sigma=0.33, filter_width=6)

Smooth the curve using a Gaussian filter

Parameters:

  • factor (float in [0, inf], (optional)) – Factor, How much to blend to the default value

  • sigma (float in [0.001, inf], (optional)) – Sigma, The shape of the gaussian distribution, lower values make it sharper

  • filter_width (int in [1, 64], (optional)) – Filter Width, How far to each side the operator will average the key values

bpy.ops.graph.ghost_curves_clear()

Clear F-Curve snapshots (Ghosts) for active Graph Editor

bpy.ops.graph.ghost_curves_create()

Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor

bpy.ops.graph.handle_type(*, type='FREE')

Set type of handle for selected keyframes

Parameters:

type (enum in Keyframe Handle Type Items, (optional)) – Type

bpy.ops.graph.hide(*, unselected=False)

Hide selected curves from Graph Editor view

Parameters:

unselected (boolean, (optional)) – Unselected, Hide unselected rather than selected curves

bpy.ops.graph.interpolation_type(*, type='CONSTANT')

Set interpolation mode for the F-Curve segments starting from the selected keyframes

Parameters:

type (enum in Beztriple Interpolation Mode Items, (optional)) – Type

bpy.ops.graph.keyframe_insert(*, type='ALL')

Insert keyframes for the specified channels

Parameters:

type (enum in ['ALL', 'SEL', 'ACTIVE', 'CURSOR_ACTIVE', 'CURSOR_SEL'], (optional)) –

Type

  • ALL All Channels – Insert a keyframe on all visible and editable F-Curves using each curve’s current value.

  • SEL Only Selected Channels – Insert a keyframe on selected F-Curves using each curve’s current value.

  • ACTIVE Only Active F-Curve – Insert a keyframe on the active F-Curve using the curve’s current value.

  • CURSOR_ACTIVE Active Channels at Cursor – Insert a keyframe for the active F-Curve at the cursor point.

  • CURSOR_SEL Selected Channels at Cursor – Insert a keyframe for selected F-Curves at the cursor point.

bpy.ops.graph.keyframe_jump(*, next=True)

Jump to previous/next keyframe

Parameters:

next (boolean, (optional)) – Next Keyframe

bpy.ops.graph.keys_to_samples()

Convert selected channels to an uneditable set of samples to save storage space

bpy.ops.graph.match_slope(*, factor=0.0)

Blend selected keys to the slope of neighboring ones

Parameters:

factor (float in [-inf, inf], (optional)) – Factor, Defines which keys to use as slope and how much to blend towards them

bpy.ops.graph.mirror(*, type='CFRA')

Flip selected keyframes over the selected mirror line

Parameters:

type (enum in ['CFRA', 'VALUE', 'YAXIS', 'XAXIS', 'MARKER'], (optional)) –

Type

  • CFRA By Times Over Current Frame – Flip times of selected keyframes using the current frame as the mirror line.

  • VALUE By Values Over Cursor Value – Flip values of selected keyframes using the cursor value (Y/Horizontal component) as the mirror line.

  • YAXIS By Times Over Zero Time – Flip times of selected keyframes, effectively reversing the order they appear in.

  • XAXIS By Values Over Zero Value – Flip values of selected keyframes (i.e. negative values become positive, and vice versa).

  • MARKER By Times Over First Selected Marker – Flip times of selected keyframes using the first selected marker as the reference point.

bpy.ops.graph.paste(*, offset='START', value_offset='NONE', merge='MIX', flipped=False)

Paste keyframes from the internal clipboard for the selected channels, starting on the current frame

Parameters:
bpy.ops.graph.previewrange_set()

Set Preview Range based on range of selected keyframes

bpy.ops.graph.push_pull(*, factor=1.0)

Exaggerate or minimize the value of the selected keys

Parameters:

factor (float in [-inf, inf], (optional)) – Factor, Control how far to push or pull the keys

bpy.ops.graph.reveal(*, select=True)

Make previously hidden curves visible again in Graph Editor view

Parameters:

select (boolean, (optional)) – Select

bpy.ops.graph.samples_to_keys()

Convert selected channels from samples to keyframes

bpy.ops.graph.scale_average(*, factor=1.0)

Scale selected key values by their combined average

Parameters:

factor (float in [-inf, inf], (optional)) – Scale Factor, The scale factor applied to the curve segments

bpy.ops.graph.scale_from_neighbor(*, factor=0.0, anchor='LEFT')

Increase or decrease the value of selected keys in relationship to the neighboring one

Parameters:

  • factor (float in [-inf, inf], (optional)) – Factor, The factor to scale keys with

  • anchor (enum in ['LEFT', 'RIGHT'], (optional)) – Reference Key, Which end of the segment to use as a reference to scale from

bpy.ops.graph.select_all(*, action='TOGGLE')

Toggle selection of all keyframes

Parameters:

action (enum in ['TOGGLE', 'SELECT', 'DESELECT', 'INVERT'], (optional)) –

Action, Selection action to execute

  • TOGGLE Toggle – Toggle selection for all elements.

  • SELECT Select – Select all elements.

  • DESELECT Deselect – Deselect all elements.

  • INVERT Invert – Invert selection of all elements.

bpy.ops.graph.select_box(*, axis_range=False, include_handles=True, tweak=False, use_curve_selection=True, xmin=0, xmax=0, ymin=0, ymax=0, wait_for_input=True, mode='SET')

Select all keyframes within the specified region

Parameters:

  • axis_range (boolean, (optional)) – Axis Range

  • include_handles (boolean, (optional)) – Include Handles, Are handles tested individually against the selection criteria

  • tweak (boolean, (optional)) – Tweak, Operator has been activated using a click-drag event

  • use_curve_selection (boolean, (optional)) – Select Curves, Allow selecting all the keyframes of a curve by selecting the calculated F-curve

  • xmin (int in [-inf, inf], (optional)) – X Min

  • xmax (int in [-inf, inf], (optional)) – X Max

  • ymin (int in [-inf, inf], (optional)) – Y Min

  • ymax (int in [-inf, inf], (optional)) – Y Max

  • wait_for_input (boolean, (optional)) – Wait for Input

  • mode (enum in ['SET', 'ADD', 'SUB'], (optional)) –

    Mode

    • SET Set – Set a new selection.

    • ADD Extend – Extend existing selection.

    • SUB Subtract – Subtract existing selection.

bpy.ops.graph.select_circle(*, x=0, y=0, radius=25, wait_for_input=True, mode='SET', use_curve_selection=True)

Select keyframe points using circle selection

Parameters:

  • x (int in [-inf, inf], (optional)) – X

  • y (int in [-inf, inf], (optional)) – Y

  • radius (int in [1, inf], (optional)) – Radius

  • wait_for_input (boolean, (optional)) – Wait for Input

  • mode (enum in ['SET', 'ADD', 'SUB'], (optional)) –

    Mode

    • SET Set – Set a new selection.

    • ADD Extend – Extend existing selection.

    • SUB Subtract – Subtract existing selection.

  • use_curve_selection (boolean, (optional)) – Select Curves, Allow selecting all the keyframes of a curve by selecting the curve itself

bpy.ops.graph.select_column(*, mode='KEYS')

Select all keyframes on the specified frame(s)

Parameters:

mode (enum in ['KEYS', 'CFRA', 'MARKERS_COLUMN', 'MARKERS_BETWEEN'], (optional)) – Mode

bpy.ops.graph.select_key_handles(*, left_handle_action='SELECT', right_handle_action='SELECT', key_action='KEEP')

For selected keyframes, select/deselect any combination of the key itself and its handles

Parameters:

  • left_handle_action (enum in ['SELECT', 'DESELECT', 'KEEP'], (optional)) –

    Left Handle, Effect on the left handle

    • SELECT Select.

    • DESELECT Deselect.

    • KEEP Keep – Leave as is.

  • right_handle_action (enum in ['SELECT', 'DESELECT', 'KEEP'], (optional)) –

    Right Handle, Effect on the right handle

    • SELECT Select.

    • DESELECT Deselect.

    • KEEP Keep – Leave as is.

  • key_action (enum in ['SELECT', 'DESELECT', 'KEEP'], (optional)) –

    Key, Effect on the key itself

    • SELECT Select.

    • DESELECT Deselect.

    • KEEP Keep – Leave as is.

bpy.ops.graph.select_lasso(*, path=None, use_smooth_stroke=False, smooth_stroke_factor=0.75, smooth_stroke_radius=35, mode='SET', use_curve_selection=True)

Select keyframe points using lasso selection

Parameters:

  • path (bpy_prop_collection of OperatorMousePath, (optional)) – Path

  • use_smooth_stroke (boolean, (optional)) – Stabilize Stroke, Selection lags behind mouse and follows a smoother path

  • smooth_stroke_factor (float in [0.5, 0.99], (optional)) – Smooth Stroke Factor, Higher values gives a smoother stroke

  • smooth_stroke_radius (int in [10, 200], (optional)) – Smooth Stroke Radius, Minimum distance from last point before selection continues

  • mode (enum in ['SET', 'ADD', 'SUB'], (optional)) –

    Mode

    • SET Set – Set a new selection.

    • ADD Extend – Extend existing selection.

    • SUB Subtract – Subtract existing selection.

  • use_curve_selection (boolean, (optional)) – Select Curves, Allow selecting all the keyframes of a curve by selecting the curve itself

bpy.ops.graph.select_leftright(*, mode='CHECK', extend=False)

Select keyframes to the left or the right of the current frame

Parameters:

  • mode (enum in ['CHECK', 'LEFT', 'RIGHT'], (optional)) – Mode

  • extend (boolean, (optional)) – Extend Select

bpy.ops.graph.select_less()

Deselect keyframes on ends of selection islands

bpy.ops.graph.select_linked()

Select keyframes occurring in the same F-Curves as selected ones

bpy.ops.graph.select_more()

Select keyframes beside already selected ones

bpy.ops.graph.shear(*, factor=0.0, direction='FROM_LEFT')

Affect the value of the keys linearly, keeping the same relationship between them using either the left or the right key as reference

Parameters:

  • factor (float in [-inf, inf], (optional)) – Shear Factor, The amount of shear to apply

  • direction (enum in ['FROM_LEFT', 'FROM_RIGHT'], (optional)) –

    Direction, Which end of the segment to use as a reference to shear from

    • FROM_LEFT From Left – Shear the keys using the left key as reference.

    • FROM_RIGHT From Right – Shear the keys using the right key as reference.

bpy.ops.graph.smooth()

Apply weighted moving means to make selected F-Curves less bumpy

bpy.ops.graph.snap(*, type='CFRA')

Snap selected keyframes to the chosen times/values

Parameters:

type (enum in ['CFRA', 'VALUE', 'NEAREST_FRAME', 'NEAREST_SECOND', 'NEAREST_MARKER', 'HORIZONTAL'], (optional)) –

Type

  • CFRA Selection to Current Frame – Snap selected keyframes to the current frame.

  • VALUE Selection to Cursor Value – Set values of selected keyframes to the cursor value (Y/Horizontal component).

  • NEAREST_FRAME Selection to Nearest Frame – Snap selected keyframes to the nearest (whole) frame (use to fix accidental subframe offsets).

  • NEAREST_SECOND Selection to Nearest Second – Snap selected keyframes to the nearest second.

  • NEAREST_MARKER Selection to Nearest Marker – Snap selected keyframes to the nearest marker.

  • HORIZONTAL Flatten Handles – Flatten handles for a smoother transition.

bpy.ops.graph.snap_cursor_value()

Place the cursor value on the average value of selected keyframes

bpy.ops.graph.sound_to_samples(*, filepath='', check_existing=False, 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_archive=False, filter_btx=False, filter_collada=False, filter_alembic=False, filter_usd=False, filter_obj=False, filter_volume=False, filter_folder=True, filter_blenlib=False, filemode=9, show_multiview=False, use_multiview=False, display_type='DEFAULT', sort_method='', low=0.0, high=100000.0, attack=0.005, release=0.2, threshold=0.0, use_accumulate=False, use_additive=False, use_square=False, sthreshold=0.1)

Bakes a sound wave to samples on selected channels

Parameters:

  • filepath (string, (optional, never None)) – File Path, Path to file

  • check_existing (boolean, (optional)) – Check Existing, Check and warn on overwriting existing files

  • filter_blender (boolean, (optional)) – Filter .blend files

  • filter_backup (boolean, (optional)) – Filter .blend files

  • filter_image (boolean, (optional)) – Filter image files

  • filter_movie (boolean, (optional)) – Filter movie files

  • filter_python (boolean, (optional)) – Filter Python files

  • filter_font (boolean, (optional)) – Filter font files

  • filter_sound (boolean, (optional)) – Filter sound files

  • filter_text (boolean, (optional)) – Filter text files

  • filter_archive (boolean, (optional)) – Filter archive files

  • filter_btx (boolean, (optional)) – Filter btx files

  • filter_collada (boolean, (optional)) – Filter COLLADA files

  • filter_alembic (boolean, (optional)) – Filter Alembic files

  • filter_usd (boolean, (optional)) – Filter USD files

  • filter_obj (boolean, (optional)) – Filter OBJ files

  • filter_volume (boolean, (optional)) – Filter OpenVDB volume files

  • filter_folder (boolean, (optional)) – Filter folders

  • filter_blenlib (boolean, (optional)) – Filter Blender IDs

  • filemode (int in [1, 9], (optional)) – File Browser Mode, The setting for the file browser mode to load a .blend file, a library or a special file

  • show_multiview (boolean, (optional)) – Enable Multi-View

  • use_multiview (boolean, (optional)) – Use Multi-View

  • display_type (enum in ['DEFAULT', 'LIST_VERTICAL', 'LIST_HORIZONTAL', 'THUMBNAIL'], (optional)) –

    Display Type

    • DEFAULT Default – Automatically determine display type for files.

    • LIST_VERTICAL Short List – Display files as short list.

    • LIST_HORIZONTAL Long List – Display files as a detailed list.

    • THUMBNAIL Thumbnails – Display files as thumbnails.

  • sort_method (enum in [], (optional)) – File sorting mode

  • low (float in [0, 100000], (optional)) – Lowest Frequency, Cutoff frequency of a high-pass filter that is applied to the audio data

  • high (float in [0, 100000], (optional)) – Highest Frequency, Cutoff frequency of a low-pass filter that is applied to the audio data

  • attack (float in [0, 2], (optional)) – Attack Time, Value for the envelope calculation that tells how fast the envelope can rise (the lower the value the steeper it can rise)

  • release (float in [0, 5], (optional)) – Release Time, Value for the envelope calculation that tells how fast the envelope can fall (the lower the value the steeper it can fall)

  • threshold (float in [0, 1], (optional)) – Threshold, Minimum amplitude value needed to influence the envelope

  • use_accumulate (boolean, (optional)) – Accumulate, Only the positive differences of the envelope amplitudes are summarized to produce the output

  • use_additive (boolean, (optional)) – Additive, The amplitudes of the envelope are summarized (or, when Accumulate is enabled, both positive and negative differences are accumulated)

  • use_square (boolean, (optional)) – Square, The output is a square curve (negative values always result in -1, and positive ones in 1)

  • sthreshold (float in [0, 1], (optional)) – Square Threshold, Square only: all values with an absolute amplitude lower than that result in 0

bpy.ops.graph.time_offset(*, frame_offset=0.0)

Shifts the value of selected keys in time

Parameters:

frame_offset (float in [-inf, inf], (optional)) – Frame Offset, How far in frames to offset the animation

bpy.ops.graph.view_all(*, include_handles=True)

Reset viewable area to show full keyframe range

Parameters:

include_handles (boolean, (optional)) – Include Handles, Include handles of keyframes when calculating extents

bpy.ops.graph.view_frame()

Move the view to the current frame

bpy.ops.graph.view_selected(*, include_handles=True)

Reset viewable area to show selected keyframe range

Parameters:

include_handles (boolean, (optional)) – Include Handles, Include handles of keyframes when calculating extents