user: What is bpy_struct and how is it used in Blender Python scripting?

assistant:      :   True when the property is hidden.

        Return type:
        :   bool

    is_property_overridable_library(*property*, */*)
    :   Check if a property is overridable.

        Parameters:
        :   **property** (*str*) – Property name.

        Returns:
        :   True when the property is overridable.

        Return type:
        :   bool

    is_property_readonly(*property*, */*)
    :   Check if a property is readonly.

        Parameters:
        :   **property** (*str*) – Property name.

        Returns:
        :   True when the property is readonly (not writable).

        Return type:
        :   bool

    is_property_set(*property*, */*, *\**, *ghost=True*)
    :   Check if a property is set, use for testing operator properties.

        Parameters:
        :   - **property** (*str*) – Property name.
            - **ghost** (*bool*) –

              Used for operators that re-run with previous settings.
              In this case the property is not marked as set,
              yet the value from the previous execution is used.

              In rare cases you may want to set this option to false.

        Returns:
        :   True when the property has been set.

        Return type:
        :   bool

    items()
    :   Returns the items of this objects custom properties (matches Python’s
        dictionary function of the same name).

        Returns:
        :   custom property key, value pairs.

        Return type:
        :   `idprop.types.IDPropertyGroupViewItems`

    keyframe_delete(*data_path*, */*, *\**, *index=-1*, *frame=bpy.context.scene.frame_current*, *group=''*)
    :   Remove a keyframe from this properties fcurve.

        Parameters:
        :   - **data_path** (*str*) – path to the property to remove a key, analogous to the fcurve’s data path.
            - **index** (*int*) – array index of the property to remove a key. Defaults to -1 removing all indices or a single channel if the property is not an array.
            - **frame** (*float*) – The frame on which the keyframe is deleted, defaulting to the current frame.
            - **group** (*str*) – The name of the group the F-Curve should be added to if it doesn’t exist yet.

        Returns:
        :   Success of keyframe deletion.

        Return type:
        :   bool

    keyframe_insert(*data_path*, */*, *\**, *index=-1*, *frame=bpy.context.scene.frame_current*, *group=''*, *options=set()*, *keytype='KEYFRAME'*)
    :   Insert a keyframe on the property given, adding fcurves and animation data when necessary.

        Parameters:
        :   - **data_path** (*str*) – path to the property to key, analogous to the fcurve’s data path.
            - **index** (*int*) – array index of the property to key.
              Defaults to -1 which will key all indices or a single channel if the property is not an array.
            - **frame** (*float*) – The frame on which the keyframe is inserted, defaulting to the current frame.
            - **group** (*str*) – The name of the group the F-Curve should be added to if it doesn’t exist yet.
            - **options** (*set**[**str**]*) –

              Optional set of flags:

              - `INSERTKEY_NEEDED` Only insert keyframes where they’re needed in the relevant F-Curves.
              - `INSERTKEY_VISUAL` Insert keyframes based on ‘visual transforms’.
              - `INSERTKEY_REPLACE` Only replace already existing keyframes.
              - `INSERTKEY_AVAILABLE` Only insert into already existing F-Curves.
              - `INSERTKEY_CYCLE_AWARE` Take cyclic extrapolation into account (Cycle-Aware Keying option).
            - **keytype** (*str*) – Type of the key: ‘KEYFRAME’, ‘BREAKDOWN’, ‘MOVING_HOLD’, ‘EXTREME’, ‘JITTER’, or ‘GENERATED’

        Returns:
        :   Success of keyframe insertion.

        Return type:
        :   bool

        This is the most simple example of inserting a keyframe from Python.

        ```
        import bpy

        obj = bpy.context.object

        # Set the keyframe at frame 1.
        obj.location = (3.0, 4.0, 10.0)
        obj.keyframe_insert(data_path="location", frame=1)
        ```

        Note that when keying data paths which contain nested properties this must be
        done from the [`ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID") subclass, in this case the [`Armature`](bpy.types.Armature.html#bpy.types.Armature "bpy.types.Armature") rather
        than the bone.

        ```
        import bpy
        from bpy.props import (
            FloatProperty,
            PointerProperty,
        )

        # Define a nested property.
        class MyPropGroup(bpy.types.PropertyGroup):
            nested: FloatProperty(name="Nested", default=0.0)

        # Register it so its available for all bones.
        bpy.utils.register_class(MyPropGroup)
        bpy.types.Bone.my_prop = PointerProperty(
            type=MyPropGroup,
            name="MyProp",
        )

        # Get a bone.
        obj = bpy.data.objects["Armature"]
        arm = obj.data

        # Set the keyframe at frame 1.
        arm.bones["Bone"].my_prop.nested = 10
        arm.keyframe_insert(
            data_path='bones["Bone"].my_prop.nested',
            frame=1,
            group="Nested Group",
        )
        ```

    keys()
    :   Returns the keys of this objects custom properties (matches Python’s
        dictionary function of the same name).

        Returns:
        :   custom property keys.

        Return type:
        :   `idprop.types.IDPropertyGroupViewKeys`

    path_from_id(*property=''*, */*)
    :   Returns the data path from the ID to this object (string).

        Parameters:
        :   **property** (*str*) – Optional property name which can be used if the path is
            to a property of this object.

        Returns:
        :   The path from [`bpy.types.bpy_struct.id_data`](#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data")
            to this struct and property (when given).

        Return type:
        :   str

    path_from_module(*property=''*, *index=-1*, */*)
    :   Returns the full data path to this struct (as a string) from the bpy module.

        Parameters:
        :   - **property** (*str*) – Optional property name to get the full path from
            - **index** (*int*) – Optional index of the property.
              “-1” means that the property has no indices.

        Returns:
        :   The full path to the data.

        Return type:
        :   str

        Raises:
        :   **ValueError** –

            if the input data cannot be converted into a full data path.

    path_resolve(*path*, *coerce=True*, */*)
    :   Returns the property from the path, raise an exception when not found.

        Parameters:
        :   - **path** (*str*) – path which this property resolves.
            - **coerce** (*bool*) – optional argument, when True, the property will be converted
              into its Python representation.

        Returns:
        :   Property value or property object.

        Return type:
        :   Any | `bpy.types.bpy_prop`

    pop(*key*, *default=None*, */*)
    :   Remove and return the value of the custom property assigned to key or default
        when not found (matches Python’s dictionary function of the same name).

        Parameters:
        :   - **key** (*str*) – The key associated with the custom property.
            - **default** (*Any*) – Optional argument for the value to return if
              *key* is not found.

        Returns:
        :   Custom property value or default.

        Return type:
        :   Any

    property_overridable_library_set(*property*, *overridable*, */*)
    :   Define a property as overridable or not (only for custom properties!).

        Parameters:
        :   - **property** (*str*) – Property name.
            - **overridable** (*bool*) – Overridable status to set.

        Returns:
        :   True when the overridable status of the property was successfully set.

        Return type:
        :   bool

    property_unset(*property*, */*)
    :   Unset a property, will use default value afterward.

        Parameters:
        :   **property** (*str*) – Property name.

    rna_ancestors()
    :   Return the chain of data containing this struct, if known.
        The first item is the root (typically an ID), the last one is the immediate parent.
        May be empty.

        Returns:
        :   a list of this object’s ancestors.

        Return type:
        :   list[[`bpy.types.bpy_struct`](#bpy.types.bpy_struct "bpy.types.bpy_struct")]

    type_recast()
    :   Return a new instance, this is needed because types
        such as textures can be changed at runtime.

        Returns:
        :   a new instance of this object with the type initialized again.

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

    values()
    :   Returns the values of this objects custom properties (matches Python’s
        dictionary function of the same name).

        Returns:
        :   custom property values.

        Return type:
        :   `idprop.types.IDPropertyGroupViewValues`

    id_data
    :   The [`bpy.types.ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID") object this data-block is from or None, (not available for all data types)

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