fake-bpy-module 20240528__py3-none-any.whl → 20240530__py3-none-any.whl

bmesh/utils/__init__.pyi

@@ -61,7 +61,7 @@ def face_split(
     face: bmesh.types.BMFace,
     vert_a: bmesh.types.BMVert,
     vert_b: bmesh.types.BMVert,
-    coords: list[float] = (),
+    coords: list[float] | None = (),
     use_exist: bool = True,
     example: bmesh.types.BMEdge = None,
 ) -> tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
@@ -74,7 +74,7 @@ def face_split(
     :param vert_b: Second vertex to cut in the face (face must contain the vert).
     :type vert_b: bmesh.types.BMVert
     :param coords: Optional argument to define points in between vert_a and vert_b.
-    :type coords: list[float]
+    :type coords: list[float] | None
     :param use_exist: .Use an existing edge if it exists (Only used when coords argument is empty or omitted)
     :type use_exist: bool
     :param example: Newly created edge will copy settings from this one.

bpy/app/handlers/__init__.pyi

@@ -45,79 +45,79 @@ import bpy.types
 
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
-animation_playback_post: list[typing.Callable[[bpy.types.Scene, None]]]
+animation_playback_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on ending animation playback
 """
 
-animation_playback_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+animation_playback_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on starting animation playback
 """
 
-annotation_post: list[typing.Callable[[bpy.types.Scene, None]]]
+annotation_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (after)
 """
 
-annotation_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+annotation_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (before)
 """
 
-composite_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
+composite_cancel: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (cancel)
 """
 
-composite_post: list[typing.Callable[[bpy.types.Scene, None]]]
+composite_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (after)
 """
 
-composite_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+composite_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (before)
 """
 
-depsgraph_update_post: list[typing.Callable[[bpy.types.Scene, None]]]
+depsgraph_update_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on depsgraph update (post)
 """
 
-depsgraph_update_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+depsgraph_update_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on depsgraph update (pre)
 """
 
-frame_change_post: list[typing.Callable[[bpy.types.Scene, None]]]
+frame_change_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ Called after frame change for playback and rendering, after the data has been evaluated for the new frame.
 """
 
-frame_change_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+frame_change_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ Called after frame change for playback and rendering, before any data is evaluated for the new frame. This makes it possible to change data and relations (for example swap an object to another mesh) for the new frame. Note that this handler is not to be used as 'before the frame changes' event. The dependency graph is not available in this handler, as data and relations may have been altered and the dependency graph has not yet been updated for that.
 """
 
-load_factory_preferences_post: list[typing.Callable[[bpy.types.Scene, None]]]
+load_factory_preferences_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading factory preferences (after)
 """
 
-load_factory_startup_post: list[typing.Callable[[bpy.types.Scene, None]]]
+load_factory_startup_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading factory startup (after)
 """
 
-load_post: list[typing.Callable[[bpy.types.Scene, None]]]
+load_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a new blend file (after). Accepts one argument: the file being loaded, an empty string for the startup-file.
 """
 
-load_post_fail: list[typing.Callable[[bpy.types.Scene, None]]]
+load_post_fail: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on failure to load a new blend file (after). Accepts one argument: the file being loaded, an empty string for the startup-file.
 """
 
-load_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+load_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a new blend file (before).Accepts one argument: the file being loaded, an empty string for the startup-file.
 """
 
-object_bake_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_cancel: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on canceling a bake job; will be called in the main thread
 """
 
-object_bake_complete: list[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_complete: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on completing a bake job; will be called in the main thread
 """
 
-object_bake_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ before starting a bake job
 """
 
@@ -125,70 +125,70 @@ persistent: typing.Any
 """ Function decorator for callback functions not to be removed when loading new files
 """
 
-redo_post: list[typing.Callable[[bpy.types.Scene, None]]]
+redo_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a redo step (after)
 """
 
-redo_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+redo_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a redo step (before)
 """
 
-render_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
+render_cancel: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on canceling a render job
 """
 
-render_complete: list[typing.Callable[[bpy.types.Scene, None]]]
+render_complete: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on completion of render job
 """
 
-render_init: list[typing.Callable[[bpy.types.Scene, None]]]
+render_init: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on initialization of a render job
 """
 
-render_post: list[typing.Callable[[bpy.types.Scene, None]]]
+render_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on render (after)
 """
 
-render_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+render_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on render (before)
 """
 
-render_stats: list[typing.Callable[[bpy.types.Scene, None]]]
-""" on printing render statistics
+render_stats: list[collections.abc.Callable[[bpy.types.Scene, None]]]
+""" on printing render statistics. Accepts one argument: the render stats (render/saving time plus in background mode frame/used [peak] memory).
 """
 
-render_write: list[typing.Callable[[bpy.types.Scene, None]]]
+render_write: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on writing a render frame (directly after the frame is written)
 """
 
-save_post: list[typing.Callable[[bpy.types.Scene, None]]]
+save_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on saving a blend file (after). Accepts one argument: the file being saved, an empty string for the startup-file.
 """
 
-save_post_fail: list[typing.Callable[[bpy.types.Scene, None]]]
+save_post_fail: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on failure to save a blend file (after). Accepts one argument: the file being saved, an empty string for the startup-file.
 """
 
-save_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+save_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on saving a blend file (before). Accepts one argument: the file being saved, an empty string for the startup-file.
 """
 
-translation_update_post: list[typing.Callable[[bpy.types.Scene, None]]]
+translation_update_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on translation settings update
 """
 
-undo_post: list[typing.Callable[[bpy.types.Scene, None]]]
+undo_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading an undo step (after)
 """
 
-undo_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+undo_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading an undo step (before)
 """
 
-version_update: list[typing.Callable[[bpy.types.Scene, None]]]
+version_update: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on ending the versioning code
 """
 
-xr_session_start_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+xr_session_start_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on starting an xr session (before)
 """

bpy/app/icons/__init__.pyi

@@ -6,17 +6,17 @@ GenericType2 = typing.TypeVar("GenericType2")
 
 def new_triangles(
     range: tuple | None,
-    coords: typing.Sequence[bytes] | None,
-    colors: typing.Sequence[bytes] | None,
+    coords: collections.abc.Sequence[bytes] | None,
+    colors: collections.abc.Sequence[bytes] | None,
 ) -> int:
     """Create a new icon from triangle geometry.
 
     :param range: Pair of ints.
     :type range: tuple | None
     :param coords: Sequence of bytes (6 floats for one triangle) for (X, Y) coordinates.
-    :type coords: typing.Sequence[bytes] | None
+    :type coords: collections.abc.Sequence[bytes] | None
     :param colors: Sequence of ints (12 for one triangles) for RGBA.
-    :type colors: typing.Sequence[bytes] | None
+    :type colors: collections.abc.Sequence[bytes] | None
     :return: Unique icon value (pass to interface icon_value argument).
     :rtype: int
     """

bpy/app/timers/__init__.pyi

@@ -36,18 +36,18 @@ import collections.abc
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
 
-def is_registered(function: typing.Callable[[], float]) -> bool:
+def is_registered(function: collections.abc.Callable[[], float]) -> bool:
     """Check if this function is registered as a timer.
 
     :param function: Function to check.
-    :type function: typing.Callable[[], float]
+    :type function: collections.abc.Callable[[], float]
     :return: True when this function is registered, otherwise False.
     :rtype: bool
     """
 
     ...
 
-def register(function: typing.Callable[[], float]):
+def register(function: collections.abc.Callable[[], float]):
     """Add a new function that will be called after the specified amount of seconds.
     The function gets no arguments and is expected to return either None or a float.
     If None is returned, the timer will be unregistered.
@@ -55,16 +55,16 @@ def register(function: typing.Callable[[], float]):
     functools.partial can be used to assign some parameters.
 
         :param function: The function that should called.
-        :type function: typing.Callable[[], float]
+        :type function: collections.abc.Callable[[], float]
     """
 
     ...
 
-def unregister(function: typing.Callable[[], float]):
+def unregister(function: collections.abc.Callable[[], float]):
     """Unregister timer.
 
     :param function: Function to unregister.
-    :type function: typing.Callable[[], float]
+    :type function: collections.abc.Callable[[], float]
     """
 
     ...

bpy/ops/bl_pkg/__init__.pyi

@@ -94,7 +94,7 @@ def extensions_show_for_update(
     execution_context: str | int | None = None,
     undo: bool | None = None,
 ):
-    """Show add-on preferences
+    """Open extensions preferences
 
     :type override_context: dict[str, typing.Any] | bpy.types.Context | None
     :type execution_context: str | int | None
@@ -156,7 +156,7 @@ def pkg_install(
     enable_on_install: bool | typing.Any | None = True,
     url: str | typing.Any = "",
 ):
-    """Undocumented, consider contributing.
+    """Download and install the extension
 
     :type override_context: dict[str, typing.Any] | bpy.types.Context | None
     :type execution_context: str | int | None
@@ -394,7 +394,7 @@ def pkg_upgrade_all(
     *,
     use_active_only: bool | typing.Any | None = False,
 ):
-    """Undocumented, consider contributing.
+    """Upgrade all the extensions to their latest version for all the remote repositories
 
     :type override_context: dict[str, typing.Any] | bpy.types.Context | None
     :type execution_context: str | int | None
@@ -447,7 +447,7 @@ def repo_sync_all(
     *,
     use_active_only: bool | typing.Any | None = False,
 ):
-    """Undocumented, consider contributing.
+    """Refresh the list of extensions for all the remote repositories
 
     :type override_context: dict[str, typing.Any] | bpy.types.Context | None
     :type execution_context: str | int | None

bpy/ops/image/__init__.pyi

@@ -294,7 +294,7 @@ def import_as_mesh_planes(
     force_reload: bool | typing.Any | None = False,
     image_sequence: bool | typing.Any | None = False,
     offset: bool | typing.Any | None = True,
-    offset_axis: str | None = "X+",
+    offset_axis: str | None = "+X",
     offset_amount: typing.Any | None = 0.1,
     align_axis: str | None = "CAM_AX",
     prev_align_axis: str | None = "NONE",
@@ -349,106 +349,106 @@ def import_as_mesh_planes(
         :type filter_movie: bool | typing.Any | None
         :param filter_folder: filter_folder
         :type filter_folder: bool | typing.Any | None
-        :param force_reload: Force Reload, Force reloading of the image if already opened elsewhere in Blender
+        :param force_reload: Force Reload, Force reload the image if it is already opened elsewhere in Blender
         :type force_reload: bool | typing.Any | None
-        :param image_sequence: Animate Image Sequences, Import sequentially numbered images as an animated image sequence instead of separate planes
+        :param image_sequence: Detect Image Sequences, Import sequentially numbered images as an animated image sequence instead of separate planes
         :type image_sequence: bool | typing.Any | None
-        :param offset: Offset Planes, Offset Planes From Each Other
+        :param offset: Offset Planes, Offset planes from each other. If disabled, multiple planes will be created at the same location
         :type offset: bool | typing.Any | None
-        :param offset_axis: Orientation, How planes are oriented relative to each others' local axis
+        :param offset_axis: Offset Direction, How planes are oriented relative to each others' local axis
 
-    X+
-    X+ -- Side by Side to the Left.
+    +X
+    +X -- Side by Side to the Left.
 
-    Y+
-    Y+ -- Side by Side, Downward.
+    +Y
+    +Y -- Side by Side, Downward.
 
-    Z+
-    Z+ -- Stacked Above.
+    +Z
+    +Z -- Stacked Above.
 
-    X-
-    X- -- Side by Side to the Right.
+    -X
+    -X -- Side by Side to the Right.
 
-    Y-
-    Y- -- Side by Side, Upward.
+    -Y
+    -Y -- Side by Side, Upward.
 
-    Z-
-    Z- -- Stacked Below.
+    -Z
+    -Z -- Stacked Below.
         :type offset_axis: str | None
-        :param offset_amount: Offset, Space between planes
+        :param offset_amount: Offset Distance, Set distance between each plane
         :type offset_amount: typing.Any | None
         :param align_axis: Align, How to align the planes
 
-    X+
-    X+ -- Facing Positive X.
+    +X
+    +X -- Facing positive X.
 
-    Y+
-    Y+ -- Facing Positive Y.
+    +Y
+    +Y -- Facing positive Y.
 
-    Z+
-    Z+ (Up) -- Facing Positive Z.
+    +Z
+    +Z -- Facing positive Z.
 
-    X-
-    X- -- Facing Negative X.
+    -X
+    -X -- Facing negative X.
 
-    Y-
-    Y- -- Facing Negative Y.
+    -Y
+    -Y -- Facing negative Y.
 
-    Z-
-    Z- (Down) -- Facing Negative Z.
+    -Z
+    -Z -- Facing negative Z.
 
     CAM
-    Face Camera -- Facing Camera.
+    Face Camera -- Facing camera.
 
     CAM_AX
-    Main Axis -- Facing the Camera's dominant axis.
+    Camera's Main Axis -- Facing the camera's dominant axis.
         :type align_axis: str | None
         :param prev_align_axis: prev_align_axis
 
-    X+
-    X+ -- Facing Positive X.
+    +X
+    +X -- Facing positive X.
 
-    Y+
-    Y+ -- Facing Positive Y.
+    +Y
+    +Y -- Facing positive Y.
 
-    Z+
-    Z+ (Up) -- Facing Positive Z.
+    +Z
+    +Z -- Facing positive Z.
 
-    X-
-    X- -- Facing Negative X.
+    -X
+    -X -- Facing negative X.
 
-    Y-
-    Y- -- Facing Negative Y.
+    -Y
+    -Y -- Facing negative Y.
 
-    Z-
-    Z- (Down) -- Facing Negative Z.
+    -Z
+    -Z -- Facing negative Z.
 
     CAM
-    Face Camera -- Facing Camera.
+    Face Camera -- Facing camera.
 
     CAM_AX
-    Main Axis -- Facing the Camera's dominant axis.
+    Camera's Main Axis -- Facing the camera's dominant axis.
 
     NONE
     Undocumented.
         :type prev_align_axis: str | None
-        :param align_track: Track Camera, Always face the camera
+        :param align_track: Track Camera, Add a constraint to make the planes track the camera
         :type align_track: bool | typing.Any | None
-        :param size_mode: Size Mode, How the size of the plane is computed
+        :param size_mode: Size Mode, Method for computing the plane size
 
     ABSOLUTE
     Absolute -- Use absolute size.
 
     CAMERA
-    Camera Relative -- Scale to the camera frame.
+    Scale to Camera Frame -- Scale to fit or fill the camera frame.
 
     DPI
-    Dpi -- Use definition of the image as dots per inch.
+    Pixels per Inch -- Scale based on pixels per inch.
 
     DPBU
-    Dots/BU -- Use definition of the image as dots per Blender Unit.
+    Pixels per Blender Unit -- Scale based on pixels per Blender Unit.
         :type size_mode: str | None
-        :param fill_mode: Scale, How large in the camera frame is the plane
+        :param fill_mode: Scale, Method to scale the plane with the camera frame
 
     FILL
     Fill -- Fill camera frame, spilling outside the frame.
@@ -471,7 +471,7 @@ def import_as_mesh_planes(
     EMISSION
     Emit -- Emission Shader.
         :type shader: str | None
-        :param emit_strength: Strength, Brightness of Emission Texture
+        :param emit_strength: Emission Strength, Strength of emission
         :type emit_strength: typing.Any | None
         :param use_transparency: Use Alpha, Use alpha channel for transparency
         :type use_transparency: bool | typing.Any | None
@@ -503,11 +503,11 @@ def import_as_mesh_planes(
     NONE
     None -- Material will cast no shadow.
         :type shadow_method: str | None
-        :param use_backface_culling: Backface Culling, Use back face culling to hide the back side of faces
+        :param use_backface_culling: Backface Culling, Use backface culling to hide the back side of faces
         :type use_backface_culling: bool | typing.Any | None
         :param show_transparent_back: Show Backface, Render multiple transparent layers (may introduce transparency sorting problems)
         :type show_transparent_back: bool | typing.Any | None
-        :param overwrite_material: Overwrite Material, Overwrite existing Material (based on material name)
+        :param overwrite_material: Overwrite Material, Overwrite existing material with the same name
         :type overwrite_material: bool | typing.Any | None
         :param interpolation: Interpolation, Texture interpolation
 

bpy/ops/node/__init__.pyi

@@ -548,6 +548,24 @@ def collapse_hide_unused_toggle(
 
     ...
 
+def connect_to_output(
+    override_context: dict[str, typing.Any] | bpy.types.Context | None = None,
+    execution_context: str | int | None = None,
+    undo: bool | None = None,
+    *,
+    run_in_geometry_nodes: bool | typing.Any | None = True,
+):
+    """Connect active node to the active output node of the node tree
+
+    :type override_context: dict[str, typing.Any] | bpy.types.Context | None
+    :type execution_context: str | int | None
+    :type undo: bool | None
+    :param run_in_geometry_nodes: Run in Geometry Nodes Editor
+    :type run_in_geometry_nodes: bool | typing.Any | None
+    """
+
+    ...
+
 def cryptomatte_layer_add(
     override_context: dict[str, typing.Any] | bpy.types.Context | None = None,
     execution_context: str | int | None = None,

bpy/ops/paint/__init__.pyi

@@ -753,6 +753,42 @@ def mask_line_gesture(
 
     ...
 
+def mask_polyline_gesture(
+    override_context: dict[str, typing.Any] | bpy.types.Context | None = None,
+    execution_context: str | int | None = None,
+    undo: bool | None = None,
+    *,
+    path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
+    use_front_faces_only: bool | typing.Any | None = False,
+    mode: str | None = "VALUE",
+    value: typing.Any | None = 1.0,
+):
+    """Mask within a shape defined by the cursor
+
+        :type override_context: dict[str, typing.Any] | bpy.types.Context | None
+        :type execution_context: str | int | None
+        :type undo: bool | None
+        :param path: Path
+        :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
+        :param use_front_faces_only: Front Faces Only, Affect only faces facing towards the view
+        :type use_front_faces_only: bool | typing.Any | None
+        :param mode: Mode
+
+    VALUE
+    Value -- Set mask to the level specified by the 'value' property.
+
+    VALUE_INVERSE
+    Value Inverted -- Set mask to the level specified by the inverted 'value' property.
+
+    INVERT
+    Invert -- Invert the mask.
+        :type mode: str | None
+        :param value: Value, Mask level to use when mode is 'Value'; zero means no masking and one is fully masked
+        :type value: typing.Any | None
+    """
+
+    ...
+
 def project_image(
     override_context: dict[str, typing.Any] | bpy.types.Context | None = None,
     execution_context: str | int | None = None,
@@ -1147,6 +1183,36 @@ def vertex_paint_toggle(
 
     ...
 
+def visibility_filter(
+    override_context: dict[str, typing.Any] | bpy.types.Context | None = None,
+    execution_context: str | int | None = None,
+    undo: bool | None = None,
+    *,
+    action: str | None = "GROW",
+    iterations: typing.Any | None = 1,
+    auto_iteration_count: bool | typing.Any | None = True,
+):
+    """Edit the visibility of the current mesh
+
+        :type override_context: dict[str, typing.Any] | bpy.types.Context | None
+        :type execution_context: str | int | None
+        :type undo: bool | None
+        :param action: Action
+
+    GROW
+    Grow Visibility -- Grow the visibility by one face based on mesh topology.
+
+    SHRINK
+    Shrink Visibility -- Shrink the visibility by one face based on mesh topology.
+        :type action: str | None
+        :param iterations: Iterations, Number of times that the filter is going to be applied
+        :type iterations: typing.Any | None
+        :param auto_iteration_count: Auto Iteration Count, Use an automatic number of iterations based on the number of vertices of the sculpt
+        :type auto_iteration_count: bool | typing.Any | None
+    """
+
+    ...
+
 def visibility_invert(
     override_context: dict[str, typing.Any] | bpy.types.Context | None = None,
     execution_context: str | int | None = None,

bpy/ops/preferences/__init__.pyi

@@ -420,7 +420,7 @@ def extension_repo_sync(
     execution_context: str | int | None = None,
     undo: bool | None = None,
 ):
-    """Synchronize the active extension repository with its remote URL
+    """Refresh the list of extensions for the active repository
 
     :type override_context: dict[str, typing.Any] | bpy.types.Context | None
     :type execution_context: str | int | None
@@ -434,7 +434,7 @@ def extension_repo_upgrade(
     execution_context: str | int | None = None,
     undo: bool | None = None,
 ):
-    """Update any outdated extensions for the active extension repository
+    """Upgrade all the extensions to their latest version for the active repository
 
     :type override_context: dict[str, typing.Any] | bpy.types.Context | None
     :type execution_context: str | int | None