PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Image
:   The final image with the generated glare added.

Glare
:   The generated glare effect isolated from the input image.
    Useful for further compositing or adjustments.

Highlights
:   The extracted bright areas used to generate the glare effect.
    Can be used to fine-tune the glare or as a base for custom effects.
user: How do I use SceneHydra(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SceneHydra(bpy_struct)

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

*class* bpy.types.SceneHydra(*bpy_struct*)
:   Scene Hydra render engine settings

    export_method
    :   How to export the Blender scene to the Hydra render engine

        - `HYDRA`
          Hydra – Fast interactive editing through native Hydra integration.
        - `USD`
          USD – Export scene through USD file, for accurate comparison with USD file export.

        Type:
        :   enum in [`'HYDRA'`, `'USD'`], default `'HYDRA'`

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

assistant: Tone Compositor Only
:   Standard:
    :   The Combined curve is applied to each channel individually, which may result in a change of hue.

    Filmlike:
    :   Keeps the hue constant.

Channel
:   The curve to show.

    C:
    :   Combined

    R:
    :   Red

    G:
    :   Green

    B:
    :   Blue

Curve
:   A Bézier curve that maps each input level (X axis) to an output level (Y axis).
    For the curve controls, see [Curve widget](../../../interface/controls/templates/curve.html#ui-curve-widget).
user: Give a detailed overview of Main Region: syntax, arguments, return values, common patterns.

assistant: The editor displays a stack of [tracks](tracks.xhtml) which work like layers in an image editing
program. Higher tracks take precedence over lower ones, although you can also choose to blend them.

Each track can contain any number of [strips](strips.xhtml) – typically Action Strips,
which are instances of actions.

The top track highlighted in orange is special: this is the Action Track. Unlike the other tracks,
it doesn’t contain strips – instead, it contains the object’s *active action*,
which is where new keyframes are added to by default.

Editors like the [Dope Sheet Editor](../dope_sheet/introduction.xhtml)
normally only show the keyframes of this active action. If you want to edit another action,
you can select it in the NLA editor and press `Tab` to enter Tweak Mode.

[image reference removed]

Tweaking an action. Notice that it’s shown in both its original track and the Action Track.
The active action is temporarily hidden.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: # Brush Settings

Each mode and brush has unique brush settings.
But there is also a lot of overlap or similar settings.
This page explains general and mode specific settings that are used across various brushes in more detail.

Changes to the settings of a brush asset are temporary and will be discarded when Blender is closed. To preserve
settings, save them to the currently active brush asset using *Save Changes to Asset*, or create a new brush asset
using *Duplicate Asset*, see [Asset Operators](brush_management.xhtml#brush-management-utility-operators). Loading a different file
while Blender remains open does not discard the settings.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: Draw a dotted line around the strokes you want to trim.
After releasing the mouse button all the points on the selected strokes
will be deleted until another intersecting stroke is found.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_cutter_example-01.png   Original drawing. | ../../../../_images/grease-pencil_modes_draw_tools_cutter_example-02.png   Lasso Selecting the strokes to be trimmed. | ../../../../_images/grease-pencil_modes_draw_tools_cutter_example-03.png   Final result. |
user: Describe FunctionNodeRotateEuler(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeRotateEuler(FunctionNode)

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"), [`FunctionNode`](bpy.types.FunctionNode.html#bpy.types.FunctionNode "bpy.types.FunctionNode")

*class* bpy.types.FunctionNodeRotateEuler(*FunctionNode*)
:   Apply a secondary Euler rotation to a given Euler rotation

    rotation_type
    :   Method used to describe the rotation

        - `AXIS_ANGLE`
          Axis Angle – Rotate around an axis by an angle.
        - `EULER`
          Euler – Rotate around the X, Y, and Z axes.

        Type:
        :   enum in [`'AXIS_ANGLE'`, `'EULER'`], default `'EULER'`

    space
    :   Base orientation for rotation

        - `OBJECT`
          Object – Rotate the input rotation in the local space of the object.
        - `LOCAL`
          Local – Rotate the input rotation in its local space.

        Type:
        :   enum in [`'OBJECT'`, `'LOCAL'`], default `'OBJECT'`

    *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: Give a detailed overview of Views: syntax, arguments, return values, common patterns.

assistant: In Tracking Mode there are three different views available. You can toggle between view modes using
the View selector, which is located in the header.
When you selected a view in the whole area of the Movie Clip editor will change.
Hence, to display a curve or dope sheet view, the editor must be split into two,
with one switched to the curve or dope sheet view.
user: Describe Controls from the Blender manual or Python API, including usage steps and snippets.

assistant: Flip `F`
:   Changes the side of the line that the tool projects geometry.

Snap `Ctrl`
:   Constrains the rotation of the line to 15 degree intervals.

Move `Ctrl`-`Spacebar`
:   Reposition the line.
user: How do I use Blender 3 in Blender? Include parameters, examples, warnings and best practices.

assistant: - [Blender 3.6 LTS](https://docs.blender.org/manual/en/3.6/)
- [Blender 3.5](https://docs.blender.org/manual/en/3.5/)
- [Blender 3.4](https://docs.blender.org/manual/en/3.4/)
- [Blender 3.3 LTS](https://docs.blender.org/manual/en/3.3/)
- [Blender 3.2](https://docs.blender.org/manual/en/3.2/)
- [Blender 3.1](https://docs.blender.org/manual/en/3.1/)
- [Blender 3.0](https://docs.blender.org/manual/en/3.0/)
user: Describe Volume from the Blender manual or Python API, including usage steps and snippets.

assistant: Intersection
:   Determines which inner part of the mesh will produce volumetric effect.

    Fast:
    :   Each face is considered as a medium interface. Gives correct results for manifold geometry
        that contains no inner part.

    Accurate:
    :   Faces are considered as medium interface only when they have different consecutive facing.
        Gives correct results as long as the max ray depth is not exceeded. Has significant memory
        overhead compared to the fast method.
user: How do I use Marker in Blender? Include parameters, examples, warnings and best practices.

assistant: # Marker

[image reference removed]

Marker schematic.

This panel contains numerical settings for marker position,
pattern and search area dimensions, and offset of anchor point from pattern center.

Enabled
:   Toggles the markers affect on the current frame.

Position X, Y
:   The X/Y positions of the marker at frame in screen coordinates.

Offset X, Y
:   The X/Y offset to parenting point.

Pattern Area Width, Height
:   The width/height of a marker’s pattern in screen coordinates.

Search Area X, Y
:   The X/Y position of search at frame relative to the marker’s position.

Search Area Width, Height
:   The width/height of the markers search in screen coordinates.
user: Explain Mask Layers in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Mask Layer panel.

Mask layers consists of one or several splines and used to “grouped” operation on splines.
Layers can be used to create complex shapes and to define how the splines interact with each other.
Splines belonging to the same layer can be animated together, for example by an item
from motion tracker footage.
Example of such tools might be parenting the whole set of splines to single motion tracking data or
simple to transform all of them together.

Opacity
:   Used to set the opacity of the mask layer.

Invert
:   Inverts the values (colors) in the mask layer.

Blend
:   The layer blending operation to perform. See [Color Blend Modes](../../glossary/index.xhtml#term-Color-Blend-Modes).

    Modes *Merge Add* and *Merge Subtract*
    give better results when using a *Feather* on overlapping masks
    than straightforward mathematical addition and subtraction.

Falloff
:   Type of the *Feather* falloff, controls the shape of the transition between black and white.

Overlap
:   Fills the self-intersecting areas.

Holes
:   Overlapping splines from the same layer will generate holes in the mask.

|  |  |
| --- | --- |
| ../../_images/movie-clip_masking_sidebar_example-overlap.png   The Overlap option example. | ../../_images/movie-clip_masking_sidebar_example-holes.png   The Holes option example. |

### Example

The purpose of mask layers can be explained with an example.
Suppose there are two unwanted people in the footage, and one of them goes from left to right, and
the other in the opposite direction. Two mask layers can then be used to mask them separately by
using a single mask data-block. At the point of intersection of these shapes they will be added together rather than
creating a hole, as would happen if they were on the same layer. If the motion is simple enough,
a single motion tracked point can be used to drive the location of the entire mask layer.
user: Provide the full official documentation entry for Rotate Rotation Node, preserving all code examples.

assistant: # Rotate Rotation Node

[image reference removed]

The *Rotate Rotation* node applies an additional rotation to a given one.

To rotate an [Euler Rotation](../../../../glossary/index.html#term-Euler-Rotation), first use the
[Euler to Rotation Node](euler_to_rotation.html).
user: How do I use Asset Shelf Region in Blender? Include parameters, examples, warnings and best practices.

assistant: Depending on the current mode, the asset shelf may be available, providing quick access to assets
for this specific mode (for example pose assets in *Pose Mode*, brush assets in *Sculpt Mode*).

See [Asset Shelf](../../interface/window_system/regions.html#ui-region-asset-shelf) for more information.
user: Provide the full official documentation entry for ShaderNodeVectorMath(ShaderNode), preserving all code examples.

assistant: # ShaderNodeVectorMath(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.ShaderNodeVectorMath(*ShaderNode*)
:   Perform vector math operation

    operation
    :   Type:
        :   enum in [Node Vec Math Items](bpy_types_enum_items/node_vec_math_items.html#rna-enum-node-vec-math-items), default `'ADD'`

    *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: Give a detailed overview of ShapeKeyBezierPoint(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ShapeKeyBezierPoint(bpy_struct)

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

*class* bpy.types.ShapeKeyBezierPoint(*bpy_struct*)
:   Point in a shape key for Bézier curves

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

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

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

    radius
    :   Radius for beveling

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

    tilt
    :   Tilt in 3D View

        Type:
        :   float in [-376.991, 376.991], 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: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Image
:   Selection of different types of media. For controls see [Data-Block Menu](../../../interface/controls/templates/data_block.xhtml#ui-data-block).
    For the options see [Image Settings](../../../editors/image/image_settings.xhtml).
user: Show practical ways to work with Custom Region in a Blender add-on or script – include code.

assistant: Enables or disables the use of a *Custom Region* for UV operations such as
[Pack Islands](#bpy-ops-uv-pack-islands).

When enabled, the previously defined user region (created using
[Set User Region](#bpy-ops-uv-custom-region-set)) becomes active and visible in the UV Editor.
This region defines the boundaries where UV islands are packed or manipulated.

Disabling this option restores the default behavior, where UV operations apply to the
standard unit square or the active UDIM tile.
user: Provide the full official documentation entry for ShaderNodeDisplacement(ShaderNode), preserving all code examples.

assistant: # ShaderNodeDisplacement(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.ShaderNodeDisplacement(*ShaderNode*)
:   Displace the surface along the surface normal

    space
    :   Space of the input height

        - `OBJECT`
          Object Space – Displacement is in object space, affected by object scale.
        - `WORLD`
          World Space – Displacement is in world space, not affected by object scale.

        Type:
        :   enum in [`'OBJECT'`, `'WORLD'`], default `'OBJECT'`

    *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: Give a detailed overview of View Layer Attribute Lookup: syntax, arguments, return values, common patterns.

assistant: The material [Attribute Node](../../render/shader_nodes/input/attribute.xhtml) in the View Layer mode
automatically searches for the attribute property in multiple locations. This, for example, can allow
setting a certain value of the custom attribute at the [Scene](../../scene_layout/scene/introduction.xhtml)
or [World](../../render/lights/world.xhtml) level, and then overriding it
differently for one [View Layer](../../render/layers/introduction.xhtml).

[image reference removed]

Context Properties of drivers don’t implement this behavior, so if necessary it has to be manually
emulated via fallback values and a conditional expression (conditions are
[Simple Expressions](drivers_panel.xhtml#drivers-simple-expressions)).

For an attribute named `attr`, the node tries the following six RNA path lookups in order:

- `["attr"]` in the active View Layer (custom property).
- `attr` in the active View Layer (built-in property).
- `["attr"]` in the active Scene.
- `attr` in the active Scene.
- `world["attr"]` in the active Scene.
- `world.attr` in the active Scene.

Depending on the specific property it may be sufficient to check only a subset of these locations.
For example, the image on the right shows how to access an attribute that is known to definitely be
a custom property with a color value.

Driver variables accessing locations that are not final in the lookup chain should use fallback values that are
invalid for the attribute (e.g. negative color values), which can then be checked by the conditional expression.
The final variable should fallback to a valid default value to be used when the property is not set at all.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Pivot constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to use as the pivot point. Can be left empty,
    in which case the pivot point is either relative to the constraint owner itself
    or not relative to anything (fixed in space).

Use Relative Offset No Target set
:   Whether the *Pivot Point* coordinates are relative to the constraint owner
    or absolute in the world. If a *Target* is set, the coordinates are always relative.

Pivot Point X, Y, Z
:   The coordinates of the pivot point.

Rotation Range
:   Euler axis and direction for which the constraint should be active.

    Always:
    :   Apply pivoting for every possible owner rotation.

    -X/-Y/-Z Rotation:
    :   Only apply pivoting if the owner’s X/Y/Z rotation is negative or zero.

    X/Y/Z Rotation:
    :   Only apply pivoting if the owner’s X/Y/Z rotation is positive or zero.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: What is Cycles Operators and how is it used in Blender Python scripting?

assistant: # Cycles Operators

bpy.ops.cycles.denoise_animation(*\**, *input_filepath=''*, *output_filepath=''*)
:   Denoise rendered animation sequence using current scene and view layer settings. Requires denoising data passes and output to OpenEXR multilayer files

    Parameters:
    :   - **input_filepath** (*string**,* *(**optional**,* *never None**)*) – Input Filepath, File path for image to denoise. If not specified, uses the render file path and frame range from the scene
        - **output_filepath** (*string**,* *(**optional**,* *never None**)*) – Output Filepath, If not specified, renders will be denoised in-place

    File:
    :   [addons_core/cycles/operators.py:49](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/cycles/operators.py#L49)

bpy.ops.cycles.merge_images(*\**, *input_filepath1=''*, *input_filepath2=''*, *output_filepath=''*)
:   Combine OpenEXR multi-layer images rendered with different sample ranges into one image with reduced noise

    Parameters:
    :   - **input_filepath1** (*string**,* *(**optional**,* *never None**)*) – Input Filepath, File path for image to merge
        - **input_filepath2** (*string**,* *(**optional**,* *never None**)*) – Input Filepath, File path for image to merge
        - **output_filepath** (*string**,* *(**optional**,* *never None**)*) – Output Filepath, File path for merged image

    File:
    :   [addons_core/cycles/operators.py:137](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/cycles/operators.py#L137)

bpy.ops.cycles.use_shading_nodes()
:   Enable nodes on a light

    File:
    :   [addons_core/cycles/operators.py:23](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/cycles/operators.py#L23)
user: Explain Use Cases in complete detail according to the official Blender documentation.

assistant: Python developers may wish to integrate Blender scripts which don’t center around Blender.

Possible uses include:

- Visualizing data by rendering images and animations.
- Image processing using Blender’s compositor.
- Video editing (using Blender’s sequencer).
- 3D file conversion.
- Development, accessing `bpy` from Python IDE’s and debugging tools for example.
- Automation.
user: Describe Unicode Problems from the Blender manual or Python API, including usage steps and snippets.

assistant: Python supports many different encodings so there is nothing stopping you from
writing a script in `latin1` or `iso-8859-15`.
See [PEP 263](https://www.python.org/dev/peps/pep-0263/).

However, this complicates matters for Blender’s Python API because `.blend` files don’t have an explicit encoding.
To avoid the problem for Python integration and script authors we have decided that all strings in blend-files
**must** be `UTF-8`, `ASCII` compatible.
This means assigning strings with different encodings to an object name, for instance, will raise an error.

Paths are an exception to this rule since the existence of non-UTF-8 paths on the user’s file system cannot be ignored.
This means seemingly harmless expressions can raise errors, e.g:

```
>>> print(bpy.data.filepath)
UnicodeEncodeError: 'ascii' codec can't encode characters in position 10-21: ordinal not in range(128)
```

```
>>> bpy.context.object.name = bpy.data.filepath
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
TypeError: bpy_struct: item.attr= val: Object.name expected a string type, not str
```

Here are two ways around file-system encoding issues:

```
>>> print(repr(bpy.data.filepath))
```

```
>>> import os
>>> filepath_bytes = os.fsencode(bpy.data.filepath)
>>> filepath_utf8 = filepath_bytes.decode('utf-8', "replace")
>>> bpy.context.object.name = filepath_utf8
```

Unicode encoding/decoding is a big topic with comprehensive Python documentation,
to keep it short about encoding problems – here are some suggestions:

- Always use UTF-8 encoding or convert to UTF-8 where the input is unknown.
- Avoid manipulating file paths as strings directly, use `os.path` functions instead.
- Use `os.fsencode()` or `os.fsdecode()` instead of built-in string decoding functions when operating on paths.
- To print paths or to include them in the user interface use `repr(path)` first
  or `"%r" % path` with string formatting.
user: Describe Data Names from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Naming Limitations

A common mistake is to assume newly created data is given the requested name.
This can cause bugs when you add data (normally imported) then reference it later by name:

```
bpy.data.meshes.new(name=meshid)

# Normally some code, function calls, etc.
bpy.data.meshes[meshid]
```

Or with name assignment:

```
obj.name = objname

# Normally some code, function calls, etc.
obj = bpy.data.meshes[objname]
```

Data names may not match the assigned values if they exceed the maximum length, are already used or an empty string.

It’s better practice not to reference objects by names at all,
once created you can store the data in a list, dictionary, on a class, etc;
there is rarely a reason to have to keep searching for the same data by name.

If you do need to use name references, it’s best to use a dictionary to maintain
a mapping between the names of the imported assets and the newly created data,
this way you don’t run this risk of referencing existing data from the blend-file, or worse modifying it.

```
# Typically declared in the main body of the function.
mesh_name_mapping = {}

mesh = bpy.data.meshes.new(name=meshid)
mesh_name_mapping[meshid] = mesh

# Normally some code, or function calls, etc.

# Use own dictionary rather than `bpy.data`.
mesh = mesh_name_mapping[meshid]
```

### Library Collisions

Blender keeps data names unique ([`bpy.types.ID.name`](bpy.types.ID.html#bpy.types.ID.name "bpy.types.ID.name")) so you can’t name two objects,
meshes, scenes, etc., the same by accident.
However, when linking in library data from another blend-file naming collisions can occur,
so it’s best to avoid referencing data by name at all.

This can be tricky at times and not even Blender handles this correctly in some cases
(when selecting the modifier object for example, you can’t select between multiple objects with the same name),
but it’s still good to try avoiding these problems in this area.
If you need to select between local and library data, there is a feature in `bpy.data` members to allow for this.

```
# Typical name lookup, could be local or library.
obj = bpy.data.objects["my_obj"]

# Library object name lookup using a pair,
# where the second argument is the library path matching bpy.types.Library.filepath.
obj = bpy.data.objects["my_obj", "//my_lib.blend"]

# Local object name look up using a pair,
# where the second argument excludes library data from being returned.
obj = bpy.data.objects["my_obj", None]

# Both the examples above also works for `get`.
obj = bpy.data.objects.get(("my_obj", None))
```
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: ### Customized triangulation

One or many “single point spline” can be used to customize the triangulation of the filled-in curves.

[image reference removed]

This is the default behavior of the *Fill Curve* node applied to the star primitive.

[image reference removed]

Here, a single curve point is joined to the star primitive to customize the triangulation.

[image reference removed]

Here, 300 single curve point are joined to the star primitive to customize the triangulation.

### Group ID

The following figures display diverse application of the Group ID.

[image reference removed]

Here, the 4 curves share the same Group ID, resulting in 1 mesh island (default behavior).

[image reference removed]

Here, the 4 curves have different Group ID, resulting in 4 mesh islands.

[image reference removed]

Here, the 4 curves are seperated into two groups based on their positions, resulting in 2 mesh islands.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: ### Format Items

A [list view](../../../../interface/controls/templates/list_view.xhtml#ui-list-view). to manage the dynamic list of inputs used in the format string.
Each entry corresponds to a value that can be inserted into the format using a placeholder.
See [Input Naming Behavior](#input-naming-behavior) to understand how inputs must be named.

Socket Type
:   The type of value for this input:

    Float:
    :   A floating-point number (e.g. `3.14`).

    Integer:
    :   An integer number (e.g. `42`).

    String:
    :   A text string.
user: Show practical ways to work with GeometryNodeInputMeshEdgeVertices(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInputMeshEdgeVertices(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.GeometryNodeInputMeshEdgeVertices(*GeometryNode*)
:   Retrieve topology information relating to each edge of a mesh

    *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: Show practical ways to work with Data ID in a Blender add-on or script – include code.

assistant: [image reference removed]

A Data ID field.

A Data ID field is similar to a Data Block Menu, but is only for selecting
(and not for other features like creating new data or managing users).

It can show the following elements:

Type
:   The icon on the left specifies the accepted data-block type.

Name
:   The text field functions as a search field by matching elements in the list.
    Press `Tab` to auto-complete names up to the level where a match is found.
    If more than one match exists, you have to continue typing.
    If you type an invalid name, the value will remain unchanged.

List
:   Lets you select the data-block directly.

Eyedropper
:   In some Data IDs there is an [Eyedropper](../buttons/eyedropper.xhtml#ui-eyedropper)
    available through the pipette icon on the right side.

(Clear Button String)
:   Click the  button on the right to clear the reference.

### ID Sub-Data

Related types of ID sub-data may become available to select,
depending on the data-block type and its intended usage.

[image reference removed]

Sub-data Example.

Vertex Group
:   If the selected Object in the *Target* field is a mesh or a lattice,
    an additional field may be displayed to select one of its vertex groups.

Bone
:   If the selected Object in the *Target* field is an armature,
    an additional field may be displayed to select one of its bones.

    Head/Tail
    :   Once a bone is selected, a numeric field may become available for specifying a point
        along the bone.
        A value of **0.0** corresponds to the bone’s head, while a value of **1.0** corresponds to its tail.
        Any values between these will result in linear interpolation (so a value of **0.5** matches
        the bone’s center).

        Use B-Bone Shape
        :   If the bone is a [bendy bone](../../../animation/armatures/bones/properties/bendy_bones.xhtml),
            clicking on this button will make the point follow the curvature of the B-spline between head and tail,
            rather than simply going in a straight line.
user: Provide the full official documentation entry for Rendering, preserving all code examples.

assistant: The render and output settings of the Sequencer Scene are the same as for regular scenes.
They can be found in the Output tab in the Properties editor. Note that these settings
follow the active scene in the window by default (unless there is a Scene pinned to the
properties editor).

When the active scene is different from the Sequencer Scene in the current workspace,
the “Render” menu will include separate options to render the Sequencer Scene (and not the active Scene).
user: Explain Mix Color Node in complete detail according to the official Blender documentation.

assistant: # Mix Color Node

The *Mix Node* mixes values, colors and vectors inputs
using a factor to control the amount of interpolation.
The *Color* mode has additional blending modes.

[image reference removed]
user: What is Toolbar and how is it used in Blender Python scripting?

assistant: # Toolbar

Mesh Edit Mode tools:

[Select](../../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or move.

    [Select Box](../../../../interface/selecting.xhtml#tool-select-box)
    :   Select geometry by dragging a box.

    [Select Circle](../../../../interface/selecting.xhtml#tool-select-circle)
    :   Select geometry by dragging a circle.

    [Select Lasso](../../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select geometry by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

[Roll](../editing/bone_roll.xhtml#tool-bone-roll)
:   Rotates a bone around its local Y axis.

Bone Size

Extrude
:   Creates a new bone connected to the last selected joint.

    Extrude to Cursor
    :   Creates a new bone between the last selected joint and the mouse position.

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

assistant: [image reference removed]

Label Size
:   Font size of the label. For example, for subordinate frames to have smaller titles.

Shrink
:   Once a node is placed in the Frame, the Frame shrinks around it so as to remove wasted space.
    At this point it is no longer possible to select the edge of the Frame to resize it, instead resizing occurs
    automatically when nodes within the Frame are rearranged.
    This behavior can be changed by disabling this option.

Text
:   When you need to display more comprehensive text, frame nodes can display the contents of a text data-block.
    This is read-only, so you will need to use the *Text Editor* to modify the contents.
user: Give a detailed overview of ConstraintTarget(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ConstraintTarget(bpy_struct)

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

*class* bpy.types.ConstraintTarget(*bpy_struct*)
:   Target object for multi-target constraints

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    *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 Volumes and how is it used in Blender Python scripting?

assistant: # Volumes

EEVEE simulates volumetric scattering by evaluating all volume objects inside the view frustum.

To achieve this, EEVEE uses several 3D textures which have a high video memory usage.
The texture dimensions can be tweaked using the *Resolution* and *Steps* parameters.

Resolution
:   Controls the quality of the volumetric effects. Lower resolution increases video memory usage and quality.

Steps
:   Number of steps to compute volumetric effects. Higher count increases video memory usage and quality.
    These samples are distributed along the view depth (view Z axis).

Distribution
:   Blend between linear and exponential sample distribution. Higher values put more samples near the camera.

Max Depth
:   Maximum surface intersection count used by accurate volume intersection method.
    Will create artifacts if it is exceeded.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Properties are available in the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Locks the current item list and types to stabilize interfaces when publishing node groups.
    When enabled, adding/removing items is disabled until the option is turned off.

### Bundle Items

List of bundle items
:   Displays one entry per element in the bundle.
    Double-click to rename.

    Add Item
    :   Add a new socket to the bundle.

    Remove Item
    :   Delete the selected socket.

Type
:   The data type for the selected item (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control is shown and used when the socket is unlinked.
user: How do I use Adding Scene Strips in Blender? Include parameters, examples, warnings and best practices.

assistant: Existing scenes can be added from the Add ‣ Scene ‣ “Scene Name”.
Additionally, any scene asset in the current file or in an [Asset Library](../../../../files/asset_libraries/introduction.xhtml) will also show up in the Add ‣ Scene.
If a scene asset is assigned to a [Catalog](../../../../files/asset_libraries/catalogs.xhtml), the catalog hierarchy will show up as a sub-menu.
When adding a scene asset as a strip, the scene is always appended/duplicated.

New scenes can also be created directly from the add menu with Add ‣ Scene ‣ Empty Scene.

Options

Start Frame
:   The first frame to start the scene strip.

Channel
:   The channel to place the strip in.

Replace Selection
:   Replace the active strip with the new scene strip.

When creating a new scene you have the following options:

Type
:   How the new scene is created.

    New:
    :   Add new Strip with a new empty Scene with default settings.

    Copy Settings:
    :   Add a new Strip, with an empty scene, and copy settings from the current scene.

    Linked Copy:
    :   Add a Strip and link in the collections from the current scene (shallow copy).

    Full Copy:
    :   Add a Strip and make a full copy of the current scene.
user: Show practical ways to work with Visibility in a Blender add-on or script – include code.

assistant: ### Ray Visibility

Objects can be set to be invisible to particular ray types.
This can be used, for example, to make an emitting mesh invisible to camera rays.
For instanced objects, visibility is inherited; if the parent object is hidden for some ray types,
the children will be hidden for these too.

In terms of performance, using these options is more efficient that using a shader node setup
that achieves the same effect.

Camera
:   Makes the object visible to the [Camera](../../cameras.xhtml);
    this includes the viewport’s perspective in viewport rendering.

Shadow
:   Enables the object to cast shadows. The object will not be capture inside the shadow maps.

### Light Probes

Objects can be set to not be captured by certain [light probe](../light_probes/index.xhtml).
This can be used, for example, to avoid animated object being recorded into static light probes.
For instanced objects, visibility is inherited; if the parent object is hidden for some ray types,
the children will be hidden for these too.

Volume
:   Makes the object visible during light probe volumes [baking](../light_probes/volume.xhtml#eevee-lightprobe-volume-bake).

Sphere
:   Makes the object visible during light probe sphere capture.

Plane
:   Makes the object visible during light probe plane capture.
user: Provide the full official documentation entry for Closure, preserving all code examples.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](evaluate_closure.xhtml) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: What is UV Map Node and how is it used in Blender Python scripting?

assistant: # UV Map Node

[image reference removed]

The *UV Map* node outputs texture coordinates from a specific [UV map](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#uv-maps-panel).
It is especially useful when working with multiple UV layouts in the same material.
The node is most commonly connected to the *Vector* input of texture nodes,
allowing textures to be placed or manipulated.