PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is USERPREF_UL_asset_libraries(UIList) and how is it used in Blender Python scripting?

assistant: # USERPREF_UL_asset_libraries(UIList)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`UIList`](bpy.types.UIList.html#bpy.types.UIList "bpy.types.UIList")

*class* bpy.types.USERPREF_UL_asset_libraries(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Bokeh
:   This is an input for the [Bokeh Image](../../input/bokeh_image.xhtml) node.

Size
:   The amount of blur, measured in pixels.
    Size can either be a single value across the entire image or a variable value controlled by an input image.

Bounding Box
:   This can be used with a [Box Mask](../../mask/box_mask.xhtml)
    matte node or with a [Mask](../../input/mask.xhtml)
    input node to restrict the area of the image the blur is applied to. This could be helpful, for example,
    when developing a node system by allowing only a small area of the image to be filtered
    thus saving composite time each time adjustments are made.
user: Explain UserExtensionRepo(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # UserExtensionRepo(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.UserExtensionRepo(*bpy_struct*)
:   Settings to define an extension repository

    access_token
    :   Personal access token, may be required by some repositories

        Type:
        :   string, default “”, (never None)

    custom_directory
    :   The local directory containing extensions

        Type:
        :   string, default “”, (never None)

    directory
    :   The local directory containing extensions

        Type:
        :   string, default “”, (readonly, never None)

    enabled
    :   Enable the repository

        Type:
        :   boolean, default False

    module
    :   Unique module identifier

        Type:
        :   string, default “”, (never None)

    name
    :   Unique repository name

        Type:
        :   string, default “”, (never None)

    remote_url
    :   Remote URL to the extension repository, the file-system may be referenced using the file URI scheme: “<file://>”

        Type:
        :   string, default “”, (never None)

    source
    :   Select if the repository is in a user managed or system provided directory

        - `USER`
          User – Repository managed by the user, stored in user directories.
        - `SYSTEM`
          System – Read-only repository provided by the system.

        Type:
        :   enum in [`'USER'`, `'SYSTEM'`], default `'USER'`

    use_access_token
    :   Repository requires an access token

        Type:
        :   boolean, default False

    use_cache
    :   Downloaded package files are deleted after installation

        Type:
        :   boolean, default False

    use_custom_directory
    :   Manually set the path for extensions to be stored. When disabled a user’s extensions directory is created.

        Type:
        :   boolean, default False

    use_remote_url
    :   Synchronize the repository with a remote URL

        Type:
        :   boolean, default False

    use_sync_on_startup
    :   Allow Blender to check for updates upon launch

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Data Type
:   Float:
    :   The output will be a single floating-point value.

    Vector:
    :   The output will be a vector of three floating-point values.
        All calculations are elementwise.

Domain
:   The [attribute domain](../attributes_reference.xhtml#attribute-domains) used for the statistics
    and to evaluate the input *Attribute* field on.
user: How do I use Set Face Set Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Face Set Node

[image reference removed]

The *Set Face Set* node controls which [face set](../../../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.html#face-sets) that faces are in.

The input node for this data is the [Face Set Node](../read/face_set.html).
user: Provide the full official documentation entry for AssetWeakReference(bpy_struct), preserving all code examples.

assistant: # AssetWeakReference(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.AssetWeakReference(*bpy_struct*)
:   Weak reference to some asset

    asset_library_identifier
    :   Type:
        :   string, default “”, (readonly, never None)

    asset_library_type
    :   - `ALL`
          All Libraries – Show assets from all of the listed asset libraries.
        - `LOCAL`
          Current File – Show the assets currently available in this Blender session.
        - `ESSENTIALS`
          Essentials – Show the basic building blocks and utilities coming with Blender.
        - `CUSTOM`
          Custom – Show assets from the asset libraries configured in the Preferences.

        Type:
        :   enum in [`'ALL'`, `'LOCAL'`, `'ESSENTIALS'`, `'CUSTOM'`], default `'ALL'`, (readonly)

    relative_asset_identifier
    :   Type:
        :   string, default “”, (readonly, never None)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Clip, preserving all code examples.

assistant: Set Scene Frames
:   See [Set Scene Frames](../editing/clip.html#bpy-ops-clip-set-scene-frames).

Prefetch
:   See [Prefetch](../editing/clip.html#bpy-ops-clip-prefetch).

Reload
:   See [Reload Clip](../editing/clip.html#bpy-ops-clip-reload).
user: Provide the full official documentation entry for Make Single User, preserving all code examples.

assistant: # Make Single User

Makes the selected or all object data-blocks single users, that is, not shared
(linked) between other objects in the blend-file.

Additionally, it can also make single-user copies of its dependencies,
like meshes, curves, materials, animations…

Type
:   These actions work on the selected objects, or on all the objects of the scene.

    All, Selected Objects

Data-blocks
:   Lets you, in addition to the menu predefined selection, choose the type of data-blocks individually.

    Object:
    :   Make single user objects.

    Object Data:
    :   Make single user object data.

    Materials:
    :   Make materials local to each data-block.

    Object Animation:
    :   Make the animation of [Object Properties](../../properties/index.html)
        data local to each object.

    Object Data Animation:
    :   Make object data (mesh, curve etc.) animation data local to each object.
user: Explain Active F-Curve in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Active F-Curve panel.

This panel displays properties for the active F-Curve.

Channel Name
:   The name of the property that’s animated by the curve.

Data Path
:   The programmatic path to the property.

RNA Array Index
:   The index into the property, for multi-value properties. As an example, the Location
    property has three values (X, Y and Z), which means it can have three different curves
    with indices 0, 1 and 2.

Display Color
:   How to determine the color of the F-Curve in the Graph editor.

    Auto Rainbow:
    :   Assigns a unique color to each curve that uses this setting.

    Auto XYZ to RGB:
    :   Detects curves that animate an X/Y/Z coordinate and colors them red/green/blue accordingly.

    User Defined:
    :   Lets you choose the color yourself.

Handle Smoothing
:   How to compute the [Bézier handles](#editors-graph-fcurves-settings-handles)
    when using the *Automatic* or *Auto Clamped* handle type.

    None:
    :   Only directly adjacent key values are considered when computing the handles.

        This older method is very simple and predictable, but it can only produce
        truly smooth curves in the most trivial cases. Notice that the red curve
        in the image above has a few kinks in the middle.

    Continuous Acceleration:
    :   A system of equations is solved in order to avoid or minimize jumps in acceleration
        at every keyframe.

        It produces much smoother curves out of the box, but necessarily means that
        any changes in the key values may affect interpolation over a significant stretch
        of the curve; although the amount of change decays exponentially with distance.
        This change propagation is stopped by any key with *Free*, *Aligned*, or *Vector*
        handles, as well as by extremes with *Auto Clamped* handles.

        The mode also tends to overshoot and oscillate more with fully *Automatic* handles
        in some cases (see the image above). So it is recommended to use *Auto Clamped* by default,
        and only switch to *Automatic* handles in places where this is desired behavior.
        That effect can also be reduced by adding in-between keys.

    [image reference removed]

    Handle smoothing mode comparison.
user: Show practical ways to work with Curve to Tube Node in a Blender add-on or script – include code.

assistant: # Curve to Tube Node

[image reference removed]

The *Curve to Tube* node generates a mesh tube along an input curve.
It creates cylindrical or custom-profiled geometry that follows the curve shape,
with flexible control over radius, resampling, capping, and UV generation.
This node is useful for modeling cables, pipes, wires, or other tubular structures.
user: How do I use Direction Buttons in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Direction buttons.

Clicking with `LMB` in the sphere and dragging the mouse cursor
lets the user change the direction by rotating the sphere.

### Shortcuts

- `LMB` (drag) rotates the direction.
- `Ctrl` (while dragging) snaps to vertical & diagonal directions.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Creating an Alpha Mask

An often overlooked use case of the Color Ramp is to turn a black-and-white image
into a colored image with transparency.

[[image reference removed]](../../../_images/compositing_types_converter_color-ramp_create-alpha-mask.png)

In the example above, a black-and-white swirl image, which is lacking an alpha channel,
is fed into the Color Ramp node as a *Factor*.

The Color Ramp node is set to a purely transparent color on the left end of the gradient,
and a fully red color on the right. As you can see in the Viewer node,
the Color Ramp node outputs an image that is transparent where the input is black,
and opaque where the input is white.

### Colorizing an Image

In this example, multiple colors are added to the color gradient,
converting a black-and-white image into a flaming swirl.

[[image reference removed]](../../../_images/compositing_types_converter_color-ramp_colorizing-image.png)

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.
user: How do I use Rendering Animations in Blender? Include parameters, examples, warnings and best practices.

assistant: # Rendering Animations

While rendering stills will allow you to view and save the image from the render buffer when
it is complete, animations are a series of images, or frames,
and are automatically saved directly out to a drive after being rendered.

After rendering the frames, you may need to edit the clips,
or first use the Compositor to do green-screen masking, matting, color correction, DOF,
and so on to the images. That result is then fed to the Sequencer where the strips are cut and
mixed and a final overlay is done.

Finally you can render out from the Sequencer and compress the frames into a playable movie clip.
user: Provide the full official documentation entry for Control Point Grid, preserving all code examples.

assistant: While a Surface can be compared to a mesh with a
[Subdivision Surface Modifier](../modifiers/generate/subdivision_surface.xhtml),
it’s more restrictive because the control points must be strictly arranged in a grid:
each “row” indicated by a yellow line must have the same number of
control points, and so does each “column” indicated by a pink line.
The only way to extend the surface is by
[extruding](editing/control_points.xhtml) a complete row or column.

The [Active Spline](properties/active_spline.xhtml) panel controls whether
the surface is cyclic (closed) in each direction of the grid, and whether Bézier
or NURBS should be used.
user: Give a detailed overview of ObjectLightLinking(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ObjectLightLinking(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.ObjectLightLinking(*bpy_struct*)
:   blocker_collection
    :   Collection which defines objects which block light from this emitter

        Type:
        :   [`Collection`](bpy.types.Collection.html#bpy.types.Collection "bpy.types.Collection")

    receiver_collection
    :   Collection which defines light linking relation of this emitter

        Type:
        :   [`Collection`](bpy.types.Collection.html#bpy.types.Collection "bpy.types.Collection")

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Keying Flag Api Items: syntax, arguments, return values, common patterns.

assistant: # Keying Flag Api Items

INSERTKEY_NEEDED:
:   Only Needed.

    Only insert keyframes where they’re needed in the relevant F-Curves.

INSERTKEY_VISUAL:
:   Visual Keying.

    Insert keyframes based on ‘visual transforms’.

INSERTKEY_REPLACE:
:   Replace Existing.

    Only replace existing keyframes.

INSERTKEY_AVAILABLE:
:   Only Available.

    Don’t create F-Curves when they don’t already exist.

INSERTKEY_CYCLE_AWARE:
:   Cycle Aware Keying.

    When inserting into a curve with cyclic extrapolation, remap the keyframe inside the cycle time range, and if changing an end key, also update the other one.
user: Show practical ways to work with Image Menu in a Blender add-on or script – include code.

assistant: ### Clear

#### Position

Resets the strips [Position Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform-rotation) to a value of zero.

#### Scale

Resets the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform-scale) to a value of one.

#### Rotation

Resets the strips [Rotation Transform](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform-rotation) to a value of zero.

#### All Transforms

Resets the strips position, scale, and rotation [Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform) to
their default values.

### Apply

#### Scale to Fit

Adjusts the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform-scale)
so the visual contents of the strip to fit exactly within the project’s
[Resolution](../../../render/output/properties/format.xhtml#bpy-types-rendersettings-resolution-x)
while maintaining the original aspect ratio.

This may mean that the transparent areas may be added
along the content’s border to fit the content in the rendered area.

#### Scale to Fill

Adjusts the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform-scale)
so the visual contents of the strip to span the project’s
[Resolution](../../../render/output/properties/format.xhtml#bpy-types-rendersettings-resolution-x)
while maintaining the original aspect ratio.

This may mean that portions of the original image no longer fit the content inside the rendered area.

#### Stretch to Fill

Adjusts the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-types-striptransform-scale)
so the visual contents of the strip to fill the project’s
[Resolution](../../../render/output/properties/format.xhtml#bpy-types-rendersettings-resolution-x).
Note, unlike the other two methods described above, *Stretch to Fill* does not maintaining the original aspect ratio.

This may mean that the original image becomes distorted to fit the content inside the rendered area.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Radius
:   Width of the bevel effect on edges.

Normal
:   Normal to apply bevel on top of, to be combined with a [Bump Node](../displacement/bump.xhtml)
    for example. When not connected, uses the surface normal.
user: Describe AOV(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # AOV(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.AOV(*bpy_struct*)
:   is_valid
    :   Is the name of the AOV conflicting

        Type:
        :   boolean, default False

    name
    :   Name of the AOV

        Type:
        :   string, default “”, (never None)

    type
    :   Data type of the AOV

        Type:
        :   enum in [`'COLOR'`, `'VALUE'`], default `'COLOR'`

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.AOV.type "bpy.types.AOV.type")
user: Describe Stroke Placement from the Blender manual or Python API, including usage steps and snippets.

assistant: # Stroke Placement

[image reference removed]

Stroke Placement pop-over.

The Stroke Placement selector helps to select the location in which strokes are drawn.

Origin:
:   Strokes are placed at Grease Pencil object origin.

3D Cursor:
:   Strokes are placed at 3D cursor.

Surface:
:   Strokes will stick on mesh surfaces.

    Offset
    :   Distance from the mesh surface to place the new strokes.

    Project Onto Selected
    :   Only project the strokes onto selected objects.

Stroke:
:   Strokes will stick on other strokes.

    Target
    :   All Points:
        :   All the points of the new stroke sticks to other strokes.

        End Points:
        :   Only the start and end points of the new stroke sticks to other strokes.

        First Point:
        :   Only the start point of the new stroke sticks to other strokes.

Stroke using different Stroke Placements.

|  |  |  |  |
| --- | --- | --- | --- |
| <../../../_images/grease-pencil_modes_draw_stroke-placement_origin.png>   Origin. | <../../../_images/grease-pencil_modes_draw_stroke-placement_3D-cursor.png>   3D Cursor. | <../../../_images/grease-pencil_modes_draw_stroke-placement_surface.png>   Surface. | <../../../_images/grease-pencil_modes_draw_stroke-placement_stroke.png>   Stroke. |
user: How do I use MaskSplinePointUW(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MaskSplinePointUW(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.MaskSplinePointUW(*bpy_struct*)
:   Single point in spline segment defining feather

    select
    :   Selection status

        Type:
        :   boolean, default False

    u
    :   U coordinate of point along spline segment

        Type:
        :   float in [0, 1], default 0.0

    weight
    :   Weight of feather point

        Type:
        :   float in [0, 1], default 0.0

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Grid Display: syntax, arguments, return values, common patterns.

assistant: Use a specific color map for the visualization of the simulation field.
This comes in handy during debugging or when making more advanced
adjustments to the simulation. For instance, if the actual color of
a fire simulation is barely visible in the viewport then changing
the color profile can help to see the real size of the flame.

Field
:   The simulation field used in the display options (e.g. density, fuel, heat).

    Comparison of a fire simulation with and without color mapping.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_gas_viewport-display_colormapping-1.png   Slice view of “fire” grid without color mapping. | ../../../../../_images/physics_fluid_type_domain_gas_viewport-display_colormapping-2.png   Slice view of “fire” grid with color mapping. |

Scale
:   Scale the selected simulation field by this value.
user: What is Videos and how is it used in Blender Python scripting?

assistant: Embed videos hosted on Blender’s PeerTube at [video.blender.org](https://video.blender.org/).

```
.. peertube:: ID
```

The `ID` is extracted from the video URL, e.g.:

`https://video.blender.org/videos/watch/47448bc1-0cc0-4bd1-b6c8-9115d8f7e08c`
The ID is: `47448bc1-0cc0-4bd1-b6c8-9115d8f7e08c`.

### Guidelines for Videos

- Prefer videos without spoken or textual explanations for easier translation.
- Do not rely solely on videos to explain features. The manual text itself should clearly document the process.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

### Unique

Plane Angle
:   The angle between the two planes of the brush, pressing `Ctrl` inverts the angle.

Dynamic Mode
:   When enabled, the angle is dynamically updated based on the surface under the brush.
    The *Plane Angle* then controls how much the angle will increase when applying pen pressure.
    When pressing `Ctrl`, it locks the plane angle to 0 degrees.

Show Cursor Preview
:   Displays a preview of the two planes
    and the angle they form during the stroke.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Limit Rotation constraint.

Limit X, Y, Z
:   The number fields determine the angle range for each axis.
    The checkboxes determine whether each range applies.

Order
:   The [Euler](../../../glossary/index.xhtml#term-Euler) order to use when applying the limits.
    Defaults to the order of the owner, or XYZ if the owner uses a non-Euler
    rotation.

Affect Transform
:   When the owner is manually rotated, restrict not just its
    [visual](../introduction.xhtml#constraint-visual-transform) rotation but also its
    *Rotation* in the [Properties Editor](../../../editors/properties_editor.xhtml)’s *Transform* panel.

Legacy Behavior
:   For backwards compatibility: make the constraint behave in the semi-broken
    way it did prior to Blender 4.2. This old behavior does not properly account
    for the looping nature of rotations, and therefore causes
    unpredictable/erratic rotation snapping. However, this behavior can still be
    useful in some specific circumstances when Owner is set to *Local Space*, and
    some older rig setups utilize that. However, that behavior is better and more
    robustly accomplished with drivers directly on the object/bone’s rotation
    properties, so new rigs should favor that approach over using this option.

[Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The space for determining and limiting the rotation of the owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`SpaceConsole.history`](bpy.types.SpaceConsole.html#bpy.types.SpaceConsole.history "bpy.types.SpaceConsole.history") | - [`SpaceConsole.scrollback`](bpy.types.SpaceConsole.html#bpy.types.SpaceConsole.scrollback "bpy.types.SpaceConsole.scrollback") |
user: Give a detailed overview of VertexGroup(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # VertexGroup(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.VertexGroup(*bpy_struct*)
:   Group of vertices, used for armature deform and other purposes

    index
    :   Index number of the vertex group

        Type:
        :   int in [0, inf], default 0, (readonly)

    lock_weight
    :   Maintain the relative weights for the group

        Type:
        :   boolean, default False

    name
    :   Vertex group name

        Type:
        :   string, default “”, (never None)

    add(*index*, *weight*, *type*)
    :   Add vertices to the group

        Parameters:
        :   - **index** (*int array* *of* *1 items in* *[**-inf**,* *inf**]*) – List of indices
            - **weight** (*float in* *[**0**,* *1**]*) – Vertex weight
            - **type** (enum in [`'REPLACE'`, `'ADD'`, `'SUBTRACT'`]) –

              Vertex assign mode

              - `REPLACE`
                Replace – Replace.
              - `ADD`
                Add – Add.
              - `SUBTRACT`
                Subtract – Subtract.

    remove(*index*)
    :   Remove vertices from the group

        Parameters:
        :   **index** (*int array* *of* *1 items in* *[**-inf**,* *inf**]*) – List of indices

    weight(*index*)
    :   Get a vertex weight from the group

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index, The index of the vertex

        Returns:
        :   Vertex weight

        Return type:
        :   float in [0, 1]

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Mesh
:   Standard geometry output.

Top
:   A boolean field with a selection of the faces on the top of the cone. If the *Fill Type*
    is set to *None*, this will be a selection of the top edges instead. If *Radius Top*
    is zero, this will be a selection of the top vertex.

Side
:   A boolean field with a selection of the faces on the side of the cone.

Bottom
:   A boolean field with a selection of the faces on the bottom of the cone. If the *Fill Type*
    is set to *None*, this will be a selection of the bottom edges instead. If *Radius Bottom*
    is zero, this will be a selection of the bottom vertex.

UV Map
:   The default UV coordinate of each face corner. This can be connected to the
    [Store Named Attribute Node](../../attribute/store_named_attribute.xhtml) for populating a [UV Map](../../../../glossary/index.xhtml#term-UV-Map).
user: Explain Committing Your Changes in complete detail according to the official Blender documentation.

assistant: After making your edits, proceed to the bottom of the page:

- Provide a clear, concise summary of your changes in the commit message box
  (e.g., “Fixed typo in Sculpting documentation”).
- Select “Commit Changes”.

This action will automatically guide you to create a “Pull Request” to submit your edits for review.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: Bundles are useful in many workflows:

- **Simplified interfaces** – group inputs into a single socket for clarity.
- **Physics simulations** – package all entities and constraints for a solver.
- **Declarative systems** – store complex structured data for evaluation later.
- **Texture sets** – combine PBR maps (Base Color, Roughness, Normal) into one socket.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Grease Pencil
:   The input Grease Pencil geometry.

Selection
:   A boolean field to determine which elements to affect.
    Elements with a value of true will be modified.

Color
:   The new color to apply.

Opacity
:   The opacity value to apply.
user: Show practical ways to work with Annotation Layers in a Blender add-on or script – include code.

assistant: When the annotation tool is enabled, the settings for managing multiple layers
can be found in the Sidebar ‣ View ‣ Annotations panel.

Opacity
:   Adjusts the opacity of existing and new strokes.

Thickness
:   Adjusts the thickness of existing and new strokes.

### Onion Skin

Shows a ghosted image of strokes made in frames before and after the current frame.
Onion skinning only works in the 3D Viewport and Sequencer.
See the Grease Pencil documentation for an explanation of
[Onion Skinning](../grease_pencil/properties/onion_skinning.html).

Before/After
:   Color to use before and after the current frame on ghost frames.
    The number defines how many frames to show before and after the current frame.
user: Explain VolumeGrid(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # VolumeGrid(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.VolumeGrid(*bpy_struct*)
:   3D volume grid

    channels
    :   Number of dimensions of the grid data type

        Type:
        :   int in [0, inf], default 0, (readonly)

    data_type
    :   Data type of voxel values

        Type:
        :   enum in [Volume Grid Data Type Items](bpy_types_enum_items/volume_grid_data_type_items.html#rna-enum-volume-grid-data-type-items), default `'UNKNOWN'`, (readonly)

    is_loaded
    :   Grid tree is loaded in memory

        Type:
        :   boolean, default False, (readonly)

    matrix_object
    :   Transformation matrix from voxel index to object space

        Type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 items in [-inf, inf], default ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)), (readonly)

    name
    :   Volume grid name

        Type:
        :   string, default “”, (readonly, never None)

    load()
    :   Load grid tree from file

        Returns:
        :   True if grid tree was successfully loaded

        Return type:
        :   boolean

    unload()
    :   Unload grid tree and voxel data from memory, leaving only metadata

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is VIEW3D_AST_brush_gpencil_weight(AssetShelf) and how is it used in Blender Python scripting?

assistant: # VIEW3D_AST_brush_gpencil_weight(AssetShelf)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`AssetShelf`](bpy.types.AssetShelf.html#bpy.types.AssetShelf "bpy.types.AssetShelf")

*class* bpy.types.VIEW3D_AST_brush_gpencil_weight(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Data Type
:   The type of data being converted.

    Float:
    :   A single float value.

    Vector:
    :   A vector (e.g. 2D) value.

Reference Dimension
:   Defines which part of the image’s dimensions the relative value refers to.

    Per Dimension:
    :   Each axis (X and Y) is scaled independently by the image width and height.

    X:
    :   The value is scaled relative to the image width.

    Y:
    :   The value is scaled relative to the image height.

    Greater:
    :   The value is scaled relative to the larger of the image dimensions.

    Smaller:
    :   The value is scaled relative to the smaller of the image dimensions.

    Diagonal:
    :   The value is scaled relative to the diagonal length of the image.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Face Index
:   The geometry-wide index of the face which the corner belongs to.

Index in Face
:   The face-local index of the corner. This is 0 for the first corner of the face,
    1 for the next corner, and so on up to (number of corners - 1) for the last corner.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: ### Creating a Slow-Motion Effect

Suppose you want to slow your strip down.
You need to affect the speed of the video clip without affecting the overall frame rate.
Select the clip and Add ‣ Effect ‣ Speed Control effect strip.

Choose the *Multiply* option in the Effect Strip panel in the Sidebar.
Set the Multiply Factor to be the factor by which you want to adjust the speed.
To cut the displayed speed by 50%, enter 0.5.
Now, a 275-frame clip will play at half speed, and thus display only the first 137 frames.

If you want the remaining frames to show in slow motion after the first set is displayed,
double the Length of the source strip
(since effects strip bounds are controlled by their source strips).
If you are using a speed factor other than 0.5 then use the formula:

`new_length = real_length / speed_factor`

That is it, set your render to animate (in this example) all 550 frames.

### Keyframing the Speed Control

[image reference removed]

Keyframing the Frame number.

To get even finer control over your clip timing, you can use curves!
While it is possible to keyframe the Multiply factor,
usually you want to keyframe the Frame number directly.

Choose the *Frame Number* option. You now have a Frame number field which you can keyframe.
If you want the strip to animate **at all** you will have to insert some keyframes,
otherwise it will look like a still. In most cases you will want to use the Graph editor view
to set the curve interpolation to Linear since the default Bézier will rarely be what you want.

### Changing Video Frame Rates

You can use the speed control to change the frame rate in frames per second (fps) of a video.
If you are rendering your video to a sequence set,
you can effectively increase or decrease the number of individual image files created,
by using a Multiply value less than or greater than one, respectively.

For example, if you captured a five-minute video at 30 fps and wanted to transfer that to film,
which runs at 24 fps, you would enter a Multiply Factor of 30/24, or 1.25
(and enable *Interpolation* frame blending to create a film blur effect).
Instead of producing `5 × 60 × 30 = 9000` frames,
Blender would produce `9000 / 1.25 = 7200 = 5 × 60 × 24` frames.
In this case, you set a *start* = 1 and *end* = 7200, set your Format output to `jpeg` 30fps,
and image files `0001.jpg` through `7200.jpg` would be rendered out,
but those images cover the entire 9000 frames. The image file `7200.jpg` is the same at frame 9000.
When you read those images back into your film blend-file at 24 fps, the strip will last exactly 5 minutes.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Resolution
:   Number of edges on the arc.

Radius
:   The radius of the arc. *Radius* mode only.

Start Angle
:   Starting angle of the arc. *Radius* mode only.

Sweep Angle
:   Length of the arc. *Radius* mode only.

Connect Center
:   Connect the arc at the center.

Invert Arc
:   Invert and draw opposite arc.

Start, Middle, End
:   The three points on the arc. *Points* mode only.
    The order of the points determines the direction (clockwise or counterclockwise) of the arc.
    The arc will always draw from Start to End via the Middle point. This can be changed by using
    the Invert Arc option.

Offset Angle
:   Offset angle of the arc. *Points* mode only.
user: What is Writing Configurations for Blender and how is it used in Blender Python scripting?

assistant: OpenColorIO configurations do not strictly specify all information needed for Blender to work optimally.
These guidelines help ensure a configuration works well:

- Use OpenColorIO v2 `display_colorspaces` and `view_transforms` with `cie_xyz_d65_interchange`
  intermediate display linear space. This is used to emulate the chosen display on the actual display.
  In older configs without this, display emulation will be disabled and wide gamut and HDR display will
  not work well. Saving colorspace metadata for images and video also depends on this.
- For every display, include a view transform without tone mapping. Blender will look for a view
  transform named `Standard` or `Un-tone-mapped` or the config wide `default_view_transform`.
  If not found, the first view transform of the display will be used. This is more important
  for OpenColorIO v1 configs without `display_colorspaces`, to determine the color space of an image
  after applying a view transform.
- Include the interop ID from the [Color Interop Forum](https://github.com/AcademySoftwareFoundation/ColorInterop)
  for every color space and display color space that you can. This helps save image and video
  with correct colorspace information. Add the interop ID as an alias of the colorspace. For
  OpenColor 2.5 configs, additionally set the native `interop_id` attribute but keep the alias
  for compatibility with older software.
- Mark HDR displays by setting `encoding: hdr-video` on the corresponding colorspace.
- For HDR view transforms, use `HDR 500 nits`, `HDR 1000 nits`, `HDR 2000 nits` or `HDR 4000 nits`
  as part of the name to automatically determine maximum luminance for mastering display metadata.
user: How do I use Key Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: Most items in this menu are documented on the Graph Editor’s [Editing F-Curves](../graph_editor/fcurves/editing.html) page.
One important difference is that scaling keyframes in the Dope Sheet Editor only moves them along the time axis
(with the Playhead serving as the pivot point); it doesn’t change their values.

The Dope Sheet editor has the following additional menu items:

Slide `Shift`-`T`
:   Lets you stretch one set of keyframes across time while compressing an adjacent set to compensate,
    leaving the combined duration the same.

    To use this operator, first select a range of three or more keyframes, then place the mouse cursor
    somewhere in the middle and press `Shift`-`T`. The range will be temporarily split in two
    at the location of the cursor, indicated by a dashed vertical line.
    If you now move the mouse, the two halves of the range will change in length,
    and the keyframes within them will move accordingly. Click `LMB` to confirm or `RMB` to cancel.

Keyframe Type `R`
:   Sets the [type](../../animation/keyframes/introduction.html#keyframe-type) of the selected keyframes.
user: Provide the full official documentation entry for ColorMixStrip(EffectStrip), preserving all code examples.

assistant: # ColorMixStrip(EffectStrip)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), [`EffectStrip`](bpy.types.EffectStrip.html#bpy.types.EffectStrip "bpy.types.EffectStrip")

*class* bpy.types.ColorMixStrip(*EffectStrip*)
:   Color Mix Strip

    blend_effect
    :   Method for controlling how the strip combines with other strips

        Type:
        :   enum in [`'DARKEN'`, `'MULTIPLY'`, `'BURN'`, `'LINEAR_BURN'`, `'LIGHTEN'`, `'SCREEN'`, `'DODGE'`, `'ADD'`, `'OVERLAY'`, `'SOFT_LIGHT'`, `'HARD_LIGHT'`, `'VIVID_LIGHT'`, `'LINEAR_LIGHT'`, `'PIN_LIGHT'`, `'DIFFERENCE'`, `'EXCLUSION'`, `'SUBTRACT'`, `'HUE'`, `'SATURATION'`, `'COLOR'`, `'VALUE'`], default `'DARKEN'`

    factor
    :   Percentage of how much the strip’s colors affect other strips

        Type:
        :   float in [0, 1], default 0.0

    input_1
    :   First input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_2
    :   Second input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_count
    :   Type:
        :   int in [0, inf], default 0, (readonly)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is LineStyleThicknessModifier_Noise(LineStyleThicknessModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleThicknessModifier_Noise(LineStyleThicknessModifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`LineStyleModifier`](bpy.types.LineStyleModifier.html#bpy.types.LineStyleModifier "bpy.types.LineStyleModifier"), [`LineStyleThicknessModifier`](bpy.types.LineStyleThicknessModifier.html#bpy.types.LineStyleThicknessModifier "bpy.types.LineStyleThicknessModifier")

*class* bpy.types.LineStyleThicknessModifier_Noise(*LineStyleThicknessModifier*)
:   Line thickness based on random noise

    amplitude
    :   Amplitude of the noise

        Type:
        :   float in [-inf, inf], default 0.0

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

        Type:
        :   float in [0, 1], default 0.0

    period
    :   Period of the noise

        Type:
        :   float in [-inf, inf], default 0.0

    seed
    :   Seed for the noise generation

        Type:
        :   int in [1, 32767], default 0

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Thickness Modifier Type Items](bpy_types_enum_items/linestyle_thickness_modifier_type_items.html#rna-enum-linestyle-thickness-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    use_asymmetric
    :   Allow thickness to be assigned asymmetrically

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleThicknessModifier_Noise.type "bpy.types.LineStyleThicknessModifier_Noise.type")