PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Python Threads are Not Supported: syntax, arguments, return values, common patterns.

assistant: # Python Threads are Not Supported

In short: Python threads cause Blender to crash in hard to diagnose ways. For
example, a crash can occur while rendering with Cycles, with Python drivers,
while a background thread is used to download some file.

So far, no work has been done to make Blender’s Python integration thread safe,
so until it’s properly supported, it’s best not make use of this.

Note that some modules in the Python standard library may use threads as well.
An example is the [multiprocessing.Queue](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue)
class.

Python threading with Blender only works properly when the threads finish up
before the script does, for example by using `threading.join()`. In other
words, they can only be used while the main Blender thread is blocked from
running.
user: Describe In Edit Mode from the Blender manual or Python API, including usage steps and snippets.

assistant: In Edit Mode, the Median Point is the averaged-out position of the
selected vertices. This means that the pivot point will shift towards
the area with the densest geometry.

In the example below, the pivot point lies perfectly in the middle
if both cubes have the same number of vertices, but heavily leans towards
the side if one cube is subdivided – even though both cubes still
have the same size.

[image reference removed]

Median points in Edit Mode.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Input is Mesh Plane. First [Subdivide Mesh Node](../mesh/operations/subdivide_mesh.html) add some
faces for capture color with [Random Value Node](../utilities/random_value.html)
used as hue in [Combine Color Node](../color/combine_color.html) on this.
Now second [Subdivide Mesh Node](../mesh/operations/subdivide_mesh.html) split each face on a lot of new.
Each one new duplicates original attribute.
Blur Attribute node mixes all attributes for each face. Due to this, the result is smoothed.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Image.render_slots`](bpy.types.Image.html#bpy.types.Image.render_slots "bpy.types.Image.render_slots") - [`RenderSlots.active`](bpy.types.RenderSlots.html#bpy.types.RenderSlots.active "bpy.types.RenderSlots.active") | - [`RenderSlots.new`](bpy.types.RenderSlots.html#bpy.types.RenderSlots.new "bpy.types.RenderSlots.new") |
user: Show practical ways to work with Array (Legacy) Modifier in a Blender add-on or script – include code.

assistant: # Array (Legacy) Modifier

The *Array* modifier creates an array of copies of the base object, with each copy being offset from
the previous one in any of a number of possible ways. Vertices in adjacent copies can be merged if they are nearby,
allowing smooth [Subdivision Surface](subdivision_surface.xhtml)
frameworks to be generated.

This modifier can be useful when combined with tileable meshes for quickly developing large scenes.
It is also useful for creating complex repetitive shapes.

Multiple Array modifiers may be active for an object at the same time
(e.g. to create complex three-dimensional constructs).
user: Explain Create Guide Index Map in complete detail according to the official Blender documentation.

assistant: # Create Guide Index Map

The *Create Guide Index Map* node generates an integer attribute named
`guide_curve_index` that maps every hair curve to its nearest *guide* curve.
Each non-guide curve is assigned the index of the guide curve it should follow.

This guide map is used by other hair grooming nodes (for example,
[Braid Hair Curves](braid_hair_curves.xhtml),
[Clump Hair Curves](clump_hair_curves.xhtml))
to organize curves into logical groups around shared guides and apply
effects consistently.

Other nodes in the [Hair Guides Nodes](index.xhtml)
category can generate a guide map internally for convenience, but the
resulting attribute is equivalent to what this node produces.
user: What is Properties Editor and how is it used in Blender Python scripting?

assistant: # Properties Editor

[image reference removed]

The Properties editor.

The Properties editor displays settings for the active scene, object, material, and other data types.
It provides access to a wide range of context-sensitive properties used throughout Blender.
user: Explain Viewport Preview in complete detail according to the official Blender documentation.

assistant: Before rendering your scene, you can save a Viewport Preview of the animation for testing in the final display.
In the Render Output panel you can choose the output *Views Format*.

The options include individual files per view, top-bottom, anaglyph among others.
Pick the one that fits your display requirements.
user: Explain WorldLighting(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # WorldLighting(bpy_struct)

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

*class* bpy.types.WorldLighting(*bpy_struct*)
:   Lighting for a World data-block

    ao_factor
    :   Factor for ambient occlusion blending

        Type:
        :   float in [0, inf], default 1.0

    distance
    :   Length of rays, defines how far away other faces give occlusion effect

        Type:
        :   float in [0, inf], default 10.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: What is MagicTexture(Texture) and how is it used in Blender Python scripting?

assistant: # MagicTexture(Texture)

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

*class* bpy.types.MagicTexture(*Texture*)
:   Procedural noise texture

    noise_depth
    :   Depth of the noise

        Type:
        :   int in [0, 30], default 2

    turbulence
    :   Turbulence of the noise

        Type:
        :   float in [0.0001, inf], default 5.0

    users_material
    :   Materials that use this texture

        Type:
        :   tuple of [`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")

        (readonly)

    users_object_modifier
    :   Object modifiers that use this texture

        Type:
        :   tuple of [`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object")

        (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: How do I use What is a Pose Asset? in Blender? Include parameters, examples, warnings and best practices.

assistant: A *pose asset* is an action that has been [marked as asset](../../../../files/asset_libraries/introduction.xhtml#asset-create),
and that contains exactly **one frame of animation** data.
Usually these are created via the *Create Pose Asset* button (see below),
but any action that is keyed on exactly one frame can be seen as pose asset.

Each pose in the library is stored in its own action data-block.
This means that it can get its own name, its own preview image,
and can be organized in [Asset Catalogs](../../../../files/asset_libraries/catalogs.xhtml).

Since a pose asset is just an action, it can also contain
[slots](../../../actions.xhtml#animation-actions-slots). That means a single pose asset
can contain a pose for more than one armature. When applying
the pose, the best matching slot for the given armature will be chosen
to read the pose from. If no good match can be found it will fall back
to the first slot. For generic pose assets, it is recommended to use single-slot actions.
That way Blender always uses the first (and only) slot, regardless of which
character the pose is applied to. If a pose is specific to two
or more characters, they can be stored in the same asset for convenience.
For info on how to create such multi-character pose assets see [Pose Creation](#pose-creation).
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Envelope modifier.

Mode
:   Deform:
    :   Replaces the original stroke with the envelope shape.

    Segments:
    :   Add segments to create the envelope shape keeping the original stroke.

    Fill:
    :   Add segments to create the envelope without the original stroke.

Spread Length
:   The number of points to skip when creating the straight segments that define the envelope.

Thickness
:   The thickness of the generated stroke segments.

Strength
:   The Opacity of the generated stroke segments.

Material Index
:   Defines the material to use on the generated stroke segments.

Skip Segments
:   The Number of generated stroke segments to skip to reduce complexity.

### Influence Filters

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Explain NodeSocketVector4D(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketVector4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVector4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

    links
    :   List of node links from or to this socket.

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

        (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: Show practical ways to work with ParticleHairKey(bpy_struct) in a Blender add-on or script – include code.

assistant: # ParticleHairKey(bpy_struct)

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

*class* bpy.types.ParticleHairKey(*bpy_struct*)
:   Particle key for hair particle system

    co
    :   Location of the hair key in object space

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    co_local
    :   Location of the hair key in its local coordinate system, relative to the emitting face

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    time
    :   Relative time of key over hair length

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

    weight
    :   Weight for cloth simulation

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

    co_object(*object*, *modifier*, *particle*)
    :   Obtain hairkey location with particle and modifier data

        Parameters:
        :   - **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (never None)) – Object
            - **modifier** ([`ParticleSystemModifier`](bpy.types.ParticleSystemModifier.html#bpy.types.ParticleSystemModifier "bpy.types.ParticleSystemModifier"), (never None)) – Particle modifier
            - **particle** ([`Particle`](bpy.types.Particle.html#bpy.types.Particle "bpy.types.Particle"), (never None)) – hair particle

        Returns:
        :   Co, Exported hairkey location

        Return type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf]

    co_object_set(*object*, *modifier*, *particle*, *co*)
    :   Set hairkey location with particle and modifier data

        Parameters:
        :   - **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (never None)) – Object
            - **modifier** ([`ParticleSystemModifier`](bpy.types.ParticleSystemModifier.html#bpy.types.ParticleSystemModifier "bpy.types.ParticleSystemModifier"), (never None)) – Particle modifier
            - **particle** ([`Particle`](bpy.types.Particle.html#bpy.types.Particle "bpy.types.Particle"), (never None)) – hair particle
            - **co** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf]) – Co, Specified hairkey location

    *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 UnitSettings(bpy_struct) and how is it used in Blender Python scripting?

assistant: # UnitSettings(bpy_struct)

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

*class* bpy.types.UnitSettings(*bpy_struct*)
:   length_unit
    :   Unit that will be used to display length values

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    mass_unit
    :   Unit that will be used to display mass values

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    scale_length
    :   Scale to use when converting between Blender units and dimensions. When working at microscopic or astronomical scale, a small or large unit scale respectively can be used to avoid numerical precision problems

        Type:
        :   float in [1e-09, inf], default 0.0

    system
    :   The unit system to use for user interface controls

        Type:
        :   enum in [`'NONE'`, `'METRIC'`, `'IMPERIAL'`], default `'NONE'`

    system_rotation
    :   Unit to use for displaying/editing rotation values

        - `DEGREES`
          Degrees – Use degrees for measuring angles and rotations.
        - `RADIANS`
          Radians.

        Type:
        :   enum in [`'DEGREES'`, `'RADIANS'`], default `'DEGREES'`

    temperature_unit
    :   Unit that will be used to display temperature values

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    time_unit
    :   Unit that will be used to display time values

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    use_separate
    :   Display units in pairs (e.g. 1m 0cm)

        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: Provide the full official documentation entry for GeometryNodeForeachGeometryElementInput(GeometryNode), preserving all code examples.

assistant: # GeometryNodeForeachGeometryElementInput(GeometryNode)

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

*class* bpy.types.GeometryNodeForeachGeometryElementInput(*GeometryNode*)
:   paired_output
    :   Zone output node that this input node is paired with

        Type:
        :   [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (readonly)

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    pair_with_output(*output_node*)
    :   Pair a zone input node with an output node.

        Parameters:
        :   **output_node** ([`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal")) – Output Node, Zone output node to pair with

        Returns:
        :   Result, True if pairing the node was successful

        Return type:
        :   boolean

    *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 ShaderNodeAttribute(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeAttribute(ShaderNode)

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

*class* bpy.types.ShaderNodeAttribute(*ShaderNode*)
:   Retrieve attributes attached to objects or geometry

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

    attribute_type
    :   General type of the attribute

        - `GEOMETRY`
          Geometry – The attribute is associated with the object geometry, and its value varies from vertex to vertex, or within the object volume.
        - `OBJECT`
          Object – The attribute is associated with the object or mesh data-block itself, and its value is uniform.
        - `INSTANCER`
          Instancer – The attribute is associated with the instancer particle system or object, falling back to the Object mode if the attribute isn’t found, or the object is not instanced.
        - `VIEW_LAYER`
          View Layer – The attribute is associated with the View Layer, Scene or World that is being rendered.

        Type:
        :   enum in [`'GEOMETRY'`, `'OBJECT'`, `'INSTANCER'`, `'VIEW_LAYER'`], default `'GEOMETRY'`

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    *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 Query Parameters, preserving all code examples.

assistant: When Blender fetches the extensions listing it passes the following arguments to make sure only
compatible extensions are listed:

- `platform`
- `blender_version`

These arguments are passed as parameters to the server via a query URL:

> URL:
> :   `https://extensions.blender.org/api/v1/extensions/`
>
> query URL:
> :   `https://extensions.blender.org/api/v1/extensions/?blender_version=4.2.0&platform=linux-x64`
user: Give a detailed overview of Cube Projection: syntax, arguments, return values, common patterns.

assistant: Projects each selected face onto the most suitable side of a virtual cube,
then places all these sides in the UV map, overlapping each other.
If you don’t want them to overlap, you can use [Pack Islands](../uv/editing.xhtml#bpy-ops-uv-pack-islands).

The cube is centered on the [Transform Pivot Point](../../../editors/3dview/controls/pivot_point/index.xhtml)
and aligned to the mesh’s local axes.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Cube Size
:   The size of the cube to project onto.

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.xhtml), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.xhtml).

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Color
:   Tint for AO output color.

Distance
:   Distance up to which other objects are considered to occlude the shading point.

Normal
:   Normal used for ambient occlusion; if nothing is connected the default shading normal is used.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Mesh
:   The input mesh whose volume is converted into a signed distance field grid.

Voxel Size
:   The size of each voxel in object space units.
    Smaller values produce higher-resolution fields that more accurately capture
    surface details, but require more memory and computation.

Band Width
:   The width of the active voxel band around the mesh surface, measured in voxels.
    Only voxels within this band store meaningful signed distance values.
    Increasing this value captures a wider region around the surface at the cost
    of additional memory.
user: Describe Format String Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Format String Node

[image reference removed]

The *Format String* node inserts values into a string using either a Python compatible
string format syntax or [Blender’s format specifier](../../../../files/file_paths.xhtml#files-path-templates-specifiers) syntax.

This node simplifies string construction, allowing values to be combined
and formatted without converting numbers to strings or using multiple concatenate nodes.
user: Explain Creating Faces in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Quad from an Edge with source automatically rotated.

If you have two vertices selected and already connected with an edge, `Ctrl`-`RMB` click
will create a planar face, also known as a quad. Blender will follow your mouse cursor
and will use the planar view from your viewport to create those quads.

For `Ctrl`-`RMB`, Blender will automatically rotate the last selected Edge (the source)
for the subsequent operations if you have at least one face created, dividing the angles created between
the newly created edge and the last two edges, creating a smooth angle between them. Blender will calculate
this angle using the last positive and negative position of the last X and Y coordinates
and the last connected unselected edge. If this angle exceeds a negative limit (following a quadrant rule)
between the recently created edge and the last two, Blender will wrap the faces.
But if you do not want Blender to rotate and smooth edges automatically when extruding from `Ctrl`-`RMB`,
you can also inhibit Blender from rotating sources using the shortcut `Shift`-`Ctrl`-`RMB`.
In this case, Blender will not rotate the source dividing the angle between those edges when creating a face.

If you have three or more vertices selected, and `Ctrl`-`RMB` click,
you will also create planar faces, but along the vertices selected, following the direction of the cursor.
This operation is similar to an extrude operation.
user: Show practical ways to work with References in a Blender add-on or script – include code.

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

assistant: # BlendImportContextLibraries(bpy_struct)

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

*class* bpy.types.BlendImportContextLibraries(*bpy_struct*)
:   Collection of source libraries, i.e. blendfile paths

    *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 NodeTreeInterfaceSocketVectorPercentage2D(NodeTreeInterfaceSocket), preserving all code examples.

assistant: # NodeTreeInterfaceSocketVectorPercentage2D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorPercentage2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [-inf, inf], default (0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *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 Tool Settings: syntax, arguments, return values, common patterns.

assistant: Filter Type
:   Fill:
    :   Fills in a single color.

    Hue:
    :   Shifts the Hue of each color.

    Saturation:
    :   Increases or decreases the saturation.

    Value:
    :   Increases or decreases the values.

    Brightness:
    :   Increases or decreases the brightness.

    Contrast:
    :   Increases or decreases the contrast.

    Smooth:
    :   Blurs or sharpens the colors.

    Red:
    :   Increases or decreases the red channel.

    Green:
    :   Increases or decreases the green channel.

    Blue:
    :   Increases or decreases the blue channel.

Fill Color
:   Set a color that will be used for the fill filter type.

Strength
:   The amount of effect the filter has on the color attribute.
user: Describe Expression from the Blender manual or Python API, including usage steps and snippets.

assistant: This is a quick way to add drivers with a scripted expression.
First click the property you want to add a driver to, then type a hash `#` and a scripted expression.

Some examples:

- `#frame`
- `#frame / 20.0`
- `#sin(frame)`
- `#cos(frame)`
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Mesh
:   The geometry to retrieve the attribute from.

Value
:   A field to evaluate on the *Source* geometry for use with the transfer method.

Group ID
:   Is evaluated on the face domain and splits the input mesh into multiple parts, each with its own id.

Sample Position
:   The position to start from when finding the closest location on the target mesh.
    By default, this is the same as if the [Position Node](../../geometry/read/position.xhtml) was connected.

Sample Group ID
:   Determines in which group the closest nearest surface is detected.
user: Give a detailed overview of Edit Lines: syntax, arguments, return values, common patterns.

assistant: Points are always connected by a straight line,
which you see when you are editing in Edit Mode or when you look at a stroke in wireframe view.
They are invisible on the rendered image and are used to construct the final stroke.
user: Describe Skin Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Skin Modifier

The *Skin* modifier uses vertices and edges to create a skinned surface,
using a per-vertex radius to better define the shape.
The output is mostly quads, although some triangles will appear around intersections.

It is a quick way to generate base meshes for sculpting and/or smooth organic shapes with
arbitrary topology.
user: What is CollectionChild(bpy_struct) and how is it used in Blender Python scripting?

assistant: # CollectionChild(bpy_struct)

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

*class* bpy.types.CollectionChild(*bpy_struct*)
:   Child collection with its collection related settings

    light_linking
    :   Light linking settings of the collection object

        Type:
        :   [`CollectionLightLinking`](bpy.types.CollectionLightLinking.html#bpy.types.CollectionLightLinking "bpy.types.CollectionLightLinking"), (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: Give a detailed overview of Line Art: syntax, arguments, return values, common patterns.

assistant: # Line Art

The *Line Art* panel is used to enable extra display options for customizing
Line Art rendering for a specific object.

[image reference removed]

Line Art panel.

Usage
:   How the object is loaded into Line Art.
    This property overrides the parent collection’s [Line Art](../../collections/collections.xhtml#scene-layout-collections-line-art) usage.

    Inherit:
    :   No special loading strategy for Line Art.
        Loading of the object is controlled by parent collection’s Line Art settings.

    Include:
    :   Force include the object into Line Art calculation
        even if its parent collection specifies otherwise.

    Intersection Only:
    :   The object will only produce intersection lines in the scene and its own geometry stays invisible.

    Occlusion Only:
    :   The object will only cause occlusion to existing feature lines and its geometry stays invisible.

    Exclude:
    :   The object will not be loaded into Line Art at all.

    No Intersection:
    :   The object will not generate intersection lines on itself or with other objects in scene.

    Force Intersection:
    :   Generate intersection lines even with objects that disabled intersection.

Override Crease
:   Allows the object to have a different crease value than the global one set in the Line Art modifier.

    Crease
    :   Override crease value for the object.

Intersection Priority
:   Assigns an intersection priority value for this object.
    The intersection line will be included into the object with the higher intersection priority value.
user: What is Operator Context Items and how is it used in Blender Python scripting?

assistant: # Operator Context Items

INVOKE_DEFAULT:
:   Invoke Default.

INVOKE_REGION_WIN:
:   Invoke Region Window.

INVOKE_REGION_CHANNELS:
:   Invoke Region Channels.

INVOKE_REGION_PREVIEW:
:   Invoke Region Preview.

INVOKE_AREA:
:   Invoke Area.

INVOKE_SCREEN:
:   Invoke Screen.

EXEC_DEFAULT:
:   Exec Default.

EXEC_REGION_WIN:
:   Exec Region Window.

EXEC_REGION_CHANNELS:
:   Exec Region Channels.

EXEC_REGION_PREVIEW:
:   Exec Region Preview.

EXEC_AREA:
:   Exec Area.

EXEC_SCREEN:
:   Exec Screen.
user: Provide the full official documentation entry for Adding Shape Keys, preserving all code examples.

assistant: When adding a new shape key with the  button next to the list,
the new shape will be a copy of the *Basis* shape,
regardless of the current visible result in the 3D Viewport.

When adding a new shape key via Specials ‣ New Shape from Mix,
the new shape is created from the currently visible vertex configuration
(including the influence of other shape keys).

For facial animation with relative shape keys, a common technique is to first create
a shape key with a complex extreme pose (e.g. *anger* or *surprise*).
You can then break it down into smaller components by applying a temporary vertex group
to the complex shape and creating a copy with *New Shape from Mix*.
This helps reduce conflicts between shape keys that would otherwise produce double effects.

### Relative Shape Keys

1. In *Object Mode*, add a new shape key in the *Shape Key* panel ().
2. *Basis* is the rest shape. “Key 1”, “Key 2”, etc. will be the new shapes.
3. Switch to *Edit Mode*, select “Key 1” in the panel.
4. Modify the mesh as desired (do not add or remove vertices).
5. Select “Key 2”. The mesh resets to the *Basis* shape.
6. Modify “Key 2” as desired, then repeat for additional shape keys.
7. Switch back to *Object Mode*.
8. Adjust the *Value* sliders for “Key 1”, “Key 2”, etc. to blend between shapes.

The example below shows, from left to right: *Basis*, “Key 1”, “Key 2”,
and a mix of “Key 1” (`1.0`) and “Key 2” (`0.8`) in *Object Mode*.

[image reference removed]

Relative shape keys example.

For practical examples, see
[Combining Shape Keys and Drivers](../drivers/workflow_examples.html#shapekey-driver-example).

### Absolute Shape Keys

[image reference removed]

Absolute shape keys workflow.

1. Add a sequence of shape keys as described above.
2. Disable the *Relative* checkbox.
3. Click the *Reset Timing* button.
4. Switch to *Object Mode*.
5. Drag *Evaluation Time* to scrub through the sequence of shapes.
user: Describe Interpolate from the Blender manual or Python API, including usage steps and snippets.

assistant: # Interpolate

The *Interpolate* tool creates an in-between keyframe
by interpolating strokes between the previous and next Grease Pencil keyframes.
When used on a frame between two keyframes, clicking and dragging will add a new *breakdown* keyframe,
interpolating the stroke’s shape based on the drag distance.

This allows artists to manually control how strokes evolve between poses or drawings,
providing fine control over the interpolation result.
user: Describe Join from the Blender manual or Python API, including usage steps and snippets.

assistant: # Join

Join merges all selected objects into the last selected *Active* object.
All object data is linked to the active object (which must be selected).
All objects must be of the same type: mesh, curve, surface or armature.
If several curves are joined, each one will keep its subtype (NURBS or Bézier).
user: What is LineStyleThicknessModifier_Tangent(LineStyleThicknessModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleThicknessModifier_Tangent(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_Tangent(*LineStyleThicknessModifier*)
:   Thickness based on the direction of the stroke

    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'`

    curve
    :   Curve used for the curve mapping

        Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

    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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    thickness_max
    :   Maximum thickness

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

    thickness_min
    :   Minimum thickness

        Type:
        :   float in [0, 10000], default 0.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

    *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_Tangent.type "bpy.types.LineStyleThicknessModifier_Tangent.type")
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: 1. Choose File ‣ New ‣ Video Editing to open the template.
2. Use the File Browser to locate your media files.
3. Drag and drop media (movies, images, or sounds) into the Sequencer area.
4. Arrange and edit the strips as needed.
5. Use Render ‣ Render Animation to export your final video.

This template offers an efficient starting point for editing projects, combining layout, settings,
and workflow elements tailored for video production.
user: Provide the full official documentation entry for Make Parent, preserving all code examples.

assistant: To parent objects, select at least two objects
(select the child objects first, and select the parent object last),
and press `Ctrl`-`P`. The *Set Parent To* menu will pop up allowing
you to select from one of several possible different parenting types.
Selecting one of the entries in *Set Parent To* confirms,
and the child/children to parent relationship is created.
The selected objects will have their ‘parent’ set to the [active object](../selecting.html#object-active),
and as a result will be ‘siblings’.

The *Set Parent To* pop-up menu is context-sensitive, which means
the number of entries it displays can change depending on what objects are selected
when the `Ctrl`-`P` shortcut is used.

Moving, rotating or scaling the parent will also usually transform the child/children.
Yet transforming the child/children of the parent will not affect the parent.
In other words, the direction of influence is from parent to child and not child to parent.

Type
:   Blender supports many different types of parenting, listed below.
    Besides parenting the selected objects, some types add a Modifier or Constraint to the child objects,
    with the parent as the target object or activates a parent property i.e. *Follow Path*.

    - Object
    - [Armature Deform](../../../animation/armatures/skinning/parenting.html)
    - Bone
    - [Curve Deform](../../../modeling/modifiers/deform/curve.html)
    - [Follow Path](../../../modeling/curves/properties/path_animation.html#curve-path-animation)
    - [Path Constraint](../../../animation/constraints/relationship/follow_path.html)
    - [Lattice Deform](../../../modeling/modifiers/deform/lattice.html)
    - [Vertex](../../../modeling/meshes/editing/vertex/make_vertex_parent.html)
    - [Vertex (Triangle)](../../../modeling/meshes/editing/vertex/make_vertex_parent.html)

Keep Transform
:   The object’s current world transform (so its absolute location, rotation and scale in the world) is computed.
    The new parent is set, and then the *Parent Inverse* matrix is computed such that after setting
    the new parent the object is still at its previous world transform.

### Parent Inverse

Blender can assign a parent without moving the child object.
This is achieved via a hidden matrix called the *Parent Inverse* matrix,
which sits between the [transform](../../../glossary/index.html#term-Transform) of the parent and the child.

When objects are parented with `Ctrl`-`P`, Parent Inverse matrix is updated.
Depending on the choice in the Set Parent menu, the object’s local location,
rotation, and scale are also updated. For more details, see [Object Parent](#object-parenting).

The Parent Inverse matrix can be cleared by using [Clear Parent Inverse](#bpy-ops-object-parent-clear).
user: What is Examples and how is it used in Blender Python scripting?

assistant: [image reference removed]

Here, the *Count* mode of the [Resample Curve Node](../operations/resample_curve.xhtml) is recreated,
except a mesh is used for the result instead of a curve. The Z axis of the position can be used
as the sample factor because the position is between zero and one for the entire line.