fake-bpy-module 20250612__py3-none-any.whl → 20260118__py3-none-any.whl

bpy/utils/__init__.pyi

@@ -23,41 +23,32 @@ def app_template_paths(*, path: str | None = None) -> None:
     """Returns valid application template paths.
 
     :param path: Optional subdir.
-    :type path: str | None
     :return: App template paths.
     """
 
 def blend_paths(
-    absolute: bool = False, packed: bool = False, local: bool = False
+    *, absolute: bool = False, packed: bool = False, local: bool = False
 ) -> list[str]:
     """Returns a list of paths to external files referenced by the loaded .blend file.
 
     :param absolute: When true the paths returned are made absolute.
-    :type absolute: bool
-    :param packed: When true skip file paths for packed data.
-    :type packed: bool
+    :param packed: When true include file paths for packed data.
     :param local: When true skip linked library paths.
-    :type local: bool
     :return: path list.
-    :rtype: list[str]
     """
 
 def escape_identifier(string: str) -> str:
     """Simple string escaping function used for animation paths.
 
     :param string: text
-    :type string: str
     :return: The escaped string.
-    :rtype: str
     """
 
 def execfile(filepath: str, *, mod: None | None = None) -> None:
     """Execute a file path as a Python script.
 
     :param filepath: Path of the script to execute.
-    :type filepath: str
     :param mod: Optional cached module, the result of a previous execution.
-    :type mod: None | None
     :return: The module which can be passed back in as mod.
     """
 
@@ -72,41 +63,30 @@ def extension_path_user(package: str, *, path: str = "", create: bool = False) -
     """Return a user writable directory associated with an extension.
 
     :param package: The __package__ of the extension.
-    :type package: str
     :param path: Optional subdirectory.
-    :type path: str
     :param create: Treat the path as a directory and create it if its not existing.
-    :type create: bool
     :return: a path.
-    :rtype: str
     """
 
-def flip_name(name: str, strip_digits: bool = False) -> str:
+def flip_name(name: str, *, strip_digits: bool = False) -> str:
     """Flip a name between left/right sides, useful for
     mirroring bone names.
 
         :param name: Bone name to flip.
-        :type name: str
         :param strip_digits: Whether to remove .### suffix.
-        :type strip_digits: bool
         :return: The flipped name.
-        :rtype: str
     """
 
 def is_path_builtin(path: str) -> bool:
     """Returns True if the path is one of the built-in paths used by Blender.
 
     :param path: Path you want to check if it is in the built-in settings directory
-    :type path: str
-    :rtype: bool
     """
 
 def is_path_extension(path: str) -> bool:
     """Returns True if the path is from an extensions repository.
 
     :param path: Path to check if it is within an extension repository.
-    :type path: str
-    :rtype: bool
     """
 
 def keyconfig_init() -> None: ...
@@ -121,12 +101,9 @@ def load_scripts(
 
         :param reload_scripts: Causes all scripts to have their unregister method
     called before loading.
-        :type reload_scripts: bool
         :param refresh_scripts: only load scripts which are not already loaded
     as modules.
-        :type refresh_scripts: bool
         :param extensions: Loads additional scripts (add-ons & app-templates).
-        :type extensions: bool
     """
 
 def load_scripts_extensions(*, reload_scripts: bool = False) -> None:
@@ -134,7 +111,6 @@ def load_scripts_extensions(*, reload_scripts: bool = False) -> None:
 
         :param reload_scripts: Causes all scripts to have their unregister method
     called before loading.
-        :type reload_scripts: bool
     """
 
 def make_rna_paths(
@@ -143,15 +119,11 @@ def make_rna_paths(
     """Create RNA "paths" from given names.
 
         :param struct_name: Name of a RNA struct (like e.g. "Scene").
-        :type struct_name: str
-        :param prop_name: Name of a RNA struct's property.
-        :type prop_name: str
+        :param prop_name: Name of a RNA structs property.
         :param enum_name: Name of a RNA enum identifier.
-        :type enum_name: str
         :return: A triple of three "RNA paths"
-    (most_complete_path, "struct.prop", "struct.prop:'enum'").
+    (most_complete_path, "struct.prop", "struct.prop:enum").
     If no enum_name is given, the third element will always be void.
-        :rtype: tuple[str, str, str]
     """
 
 def manual_language_code(default="en") -> str:
@@ -159,19 +131,16 @@ def manual_language_code(default="en") -> str:
 
         :return: The language code used for user manual URL component based on the current language user-preference,
     falling back to the default when unavailable.
-        :rtype: str
     """
 
 def manual_map() -> None: ...
-def modules_from_path(path: str, loaded_modules) -> list:
+def modules_from_path(path: str, loaded_modules: set) -> list:
     """Load all modules in a path and return them as a list.
 
         :param path: this path is scanned for scripts and packages.
-        :type path: str
         :param loaded_modules: already loaded module names, files matching these
     names will be ignored.
         :return: all loaded modules.
-        :rtype: list
     """
 
 def preset_find(name, preset_path, *, display_name=False, ext=".py") -> None: ...
@@ -179,9 +148,7 @@ def preset_paths(subdir: str) -> list[str]:
     """Returns a list of paths for a specific preset.
 
     :param subdir: preset subdirectory (must not be an absolute path).
-    :type subdir: str
     :return: Script paths.
-    :rtype: list[str]
     """
 
 def refresh_script_paths() -> None:
@@ -208,7 +175,6 @@ def register_class(
     """Register a subclass of a Blender type class.
 
     :param cls: Registerable Blender class type.
-    :type cls: type[bpy.types.Panel | bpy.types.UIList | bpy.types.Menu | bpy.types.Header | bpy.types.Operator | bpy.types.KeyingSetInfo | bpy.types.RenderEngine | bpy.types.AssetShelf | bpy.types.FileHandler | bpy.types.PropertyGroup | bpy.types.AddonPreferences | bpy.types.NodeTree | bpy.types.Node | bpy.types.NodeSocket]
     """
 
 def register_classes_factory(classes) -> None:
@@ -225,14 +191,12 @@ def register_cli_command(id: str, execute: collections.abc.Callable) -> None:
         :param id: The command identifier (must pass an str.isidentifier check).
 
     If the id is already registered, a warning is printed and the command is inaccessible to prevent accidents invoking the wrong command.
-        :type id: str
         :param execute: Callback, taking a single list of strings and returns an int.
     The arguments are built from all command-line arguments following the command id.
     The return value should be 0 for success, 1 on failure (specific error codes from the os module can also be used).
-        :type execute: collections.abc.Callable
         :return: The command handle which can be passed to `unregister_cli_command`.
 
-    This uses Python's capsule type however the result should be considered an opaque handle only used for unregistering.
+    This uses Pythons capsule type however the result should be considered an opaque handle only used for unregistering.
     """
 
 def register_manual_map(manual_hook) -> None: ...
@@ -247,9 +211,7 @@ def register_preset_path(path: str) -> bool:
     When the __init__.py is in the same location as a presets directory.
     For example an operators preset would be located under: presets/operator/{operator.id}/
     where operator.id is the bl_idname of the operator.
-        :type path: str
         :return: success
-        :rtype: bool
     """
 
 def register_submodule_factory(
@@ -260,45 +222,34 @@ def register_submodule_factory(
     calling their register & unregister functions.
 
         :param module_name: The module name, typically __name__.
-        :type module_name: str
         :param submodule_names: List of submodule names to load and unload.
-        :type submodule_names: list[str]
         :return: register and unregister functions.
-        :rtype: tuple[collections.abc.Callable[None], collections.abc.Callable[None]]
     """
 
 def register_tool(
     tool_cls: type[bpy.types.WorkSpaceTool],
     *,
-    after: None | collections.abc.Sequence[str] | None = None,
+    after: None | collections.abc.Sequence[str] | set[str] | None = None,
     separator: bool = False,
     group: bool = False,
 ) -> None:
     """Register a tool in the toolbar.
 
     :param tool_cls: A tool subclass.
-    :type tool_cls: type[bpy.types.WorkSpaceTool]
     :param after: Optional identifiers this tool will be added after.
-    :type after: None | collections.abc.Sequence[str] | None
     :param separator: When true, add a separator before this tool.
-    :type separator: bool
     :param group: When true, add a new nested group of tools.
-    :type group: bool
     """
 
 def resource_path(
-    type: str, major: int = bpy.app.version[0], minor: str = bpy.app.version[1]
+    type: str, *, major: int = bpy.app.version[0], minor: int = bpy.app.version[1]
 ) -> str:
     """Return the base path for storing system files.
 
-    :param type: string in ['USER', 'LOCAL', 'SYSTEM'].
-    :type type: str
+    :param type: string in [USER, LOCAL, SYSTEM].
     :param major: major version, defaults to current.
-    :type major: int
     :param minor: minor version, defaults to current.
-    :type minor: str
     :return: the resource path (not necessarily existing).
-    :rtype: str
     """
 
 def script_path_user() -> None:
@@ -315,17 +266,11 @@ def script_paths(
     """Returns a list of valid script paths.
 
     :param subdir: Optional subdir.
-    :type subdir: str | None
     :param user_pref: Include the user preference script paths.
-    :type user_pref: bool
     :param check_all: Include local, user and system paths rather just the paths Blender uses.
-    :type check_all: bool
     :param use_user: Include user paths
-    :type use_user: bool
     :param use_system_environment: Include BLENDER_SYSTEM_SCRIPTS variable path
-    :type use_system_environment: bool
     :return: script paths.
-    :rtype: list[str]
     """
 
 def script_paths_pref() -> None:
@@ -339,9 +284,7 @@ def smpte_from_frame(frame: float, *, fps=None, fps_base=None) -> str:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param frame: frame number.
-        :type frame: float
         :return: the frame string.
-        :rtype: str
     """
 
 def smpte_from_seconds(time: float, *, fps=None, fps_base=None) -> str:
@@ -349,16 +292,13 @@ def smpte_from_seconds(time: float, *, fps=None, fps_base=None) -> str:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
-        :type time: float
         :return: the frame string.
-        :rtype: str
     """
 
 def time_from_frame(frame: float, *, fps=None, fps_base=None) -> None:
     """Returns the time from a frame number .If fps and fps_base are not given the current scene is used.
 
     :param frame: number.
-    :type frame: float
     :return: the time in seconds.
     """
 
@@ -367,9 +307,7 @@ def time_to_frame(time: float, *, fps=None, fps_base=None) -> float:
     as a datetime.timedelta object.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
-        :type time: float
         :return: The frame.
-        :rtype: float
     """
 
 def unescape_identifier(string: str) -> str:
@@ -377,9 +315,7 @@ def unescape_identifier(string: str) -> str:
     This performs the reverse of `escape_identifier`.
 
         :param string: text
-        :type string: str
         :return: The un-escaped string.
-        :rtype: str
     """
 
 def unregister_class(
@@ -405,7 +341,6 @@ def unregister_class(
         :param cls: Blender type class,
     see `bpy.utils.register_class` for classes which can
     be registered.
-        :type cls: type[bpy.types.Panel | bpy.types.UIList | bpy.types.Menu | bpy.types.Header | bpy.types.Operator | bpy.types.KeyingSetInfo | bpy.types.RenderEngine | bpy.types.AssetShelf | bpy.types.FileHandler | bpy.types.PropertyGroup | bpy.types.AddonPreferences | bpy.types.NodeTree | bpy.types.Node | bpy.types.NodeSocket]
     """
 
 def unregister_cli_command(handle) -> None:
@@ -421,21 +356,15 @@ def unregister_preset_path(path: str) -> bool:
         :param path: preset directory (must be an absolute path).
 
     This must match the registered path exactly.
-        :type path: str
         :return: success
-        :rtype: bool
     """
 
 def unregister_tool(tool_cls) -> None: ...
 def user_resource(resource_type: str, *, path: str = "", create: bool = False) -> str:
     """Return a user resource path (normally from the users home directory).
 
-    :param resource_type: Resource type in ['DATAFILES', 'CONFIG', 'SCRIPTS', 'EXTENSIONS'].
-    :type resource_type: str
+    :param resource_type: Resource type in [DATAFILES, CONFIG, SCRIPTS, EXTENSIONS].
     :param path: Optional subdirectory.
-    :type path: str
     :param create: Treat the path as a directory and create it if its not existing.
-    :type create: bool
     :return: a path.
-    :rtype: str
     """

bpy/utils/previews/__init__.pyi

@@ -20,7 +20,7 @@ import numpy.typing as npt
 import bpy.types
 
 class ImagePreviewCollection(dict[str, bpy.types.ImagePreview]):
-    """Dictionary-like class of previews.This is a subclass of Python's built-in dict type,
+    """Dictionary-like class of previews.This is a subclass of Pythons built-in dict type,
     used to store multiple image previews.
     """
 
@@ -40,36 +40,27 @@ class ImagePreviewCollection(dict[str, bpy.types.ImagePreview]):
         """Generate a new preview from given file path.
 
         :param name: The name (unique id) identifying the preview.
-        :type name: str | None
         :param filepath: The file path to generate the preview from.
-        :type filepath: bytes | str | None
-        :param filetype: The type of file, needed to generate the preview in ['IMAGE', 'MOVIE', 'BLEND', 'FONT'].
-        :type filetype: str | None
+        :param filetype: The type of file, needed to generate the preview in [IMAGE, MOVIE, BLEND, FONT, OBJECT_IO].
         :param force_reload: If True, force running thumbnail manager even if preview already exists in cache.
-        :type force_reload: bool | None
         :return: The Preview matching given name, or a new empty one.
-        :rtype: bpy.types.ImagePreview
         """
 
     def new(self, name: str | None) -> bpy.types.ImagePreview:
         """Generate a new empty preview.
 
         :param name: The name (unique id) identifying the preview.
-        :type name: str | None
         :return: The Preview matching given name, or a new empty one.
-        :rtype: bpy.types.ImagePreview
         """
 
 def new() -> ImagePreviewCollection:
     """
 
     :return: a new preview collection.
-    :rtype: ImagePreviewCollection
     """
 
 def remove(pcoll: ImagePreviewCollection | None) -> None:
     """Remove the specified previews collection.
 
     :param pcoll: Preview collection to close.
-    :type pcoll: ImagePreviewCollection | None
     """

bpy/utils/units/__init__.pyi

@@ -12,6 +12,7 @@ def to_string(
     unit_system: str | None,
     unit_category: str | None,
     value: float | None,
+    *,
     precision: int | None = 3,
     split_unit: bool | None = False,
     compatible_unit: bool | None = False,
@@ -19,47 +20,36 @@ def to_string(
     """Convert a given input float value into a string with units.
 
         :param unit_system: The unit system, from `bpy.utils.units.systems`.
-        :type unit_system: str | None
         :param unit_category: The category of data we are converting (length, area, rotation, etc.),
     from `bpy.utils.units.categories`.
-        :type unit_category: str | None
         :param value: The value to convert to a string.
-        :type value: float | None
         :param precision: Number of digits after the comma.
-        :type precision: int | None
         :param split_unit: Whether to use several units if needed (1m1cm), or always only one (1.01m).
-        :type split_unit: bool | None
-        :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer UTF8 ones (1m²).
-        :type compatible_unit: bool | None
+        :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer UTF8 ones (1m).
         :return: The converted string.
-        :rtype: str
     """
 
 def to_value(
     unit_system: str | None,
     unit_category: str | None,
     str_input: str | None,
+    *,
     str_ref_unit: None | str | None = None,
 ) -> float:
     """Convert a given input string into a float value.
 
         :param unit_system: The unit system, from `bpy.utils.units.systems`.
-        :type unit_system: str | None
         :param unit_category: The category of data we are converting (length, area, rotation, etc.),
     from `bpy.utils.units.categories`.
-        :type unit_category: str | None
         :param str_input: The string to convert to a float value.
-        :type str_input: str | None
         :param str_ref_unit: A reference string from which to extract a default unit, if none is found in str_input.
-        :type str_ref_unit: None | str | None
         :return: The converted/interpreted value.
-        :rtype: float
     """
 
 categories: typing.Any
-""" Constant value bpy.utils.units.categories(NONE='NONE', LENGTH='LENGTH', AREA='AREA', VOLUME='VOLUME', MASS='MASS', ROTATION='ROTATION', TIME='TIME', TIME_ABSOLUTE='TIME_ABSOLUTE', VELOCITY='VELOCITY', ACCELERATION='ACCELERATION', CAMERA='CAMERA', POWER='POWER', TEMPERATURE='TEMPERATURE', WAVELENGTH='WAVELENGTH', COLOR_TEMPERATURE='COLOR_TEMPERATURE', FREQUENCY='FREQUENCY')
+""" Constant value bpy.utils.units.categories(NONE=NONE, LENGTH=LENGTH, AREA=AREA, VOLUME=VOLUME, MASS=MASS, ROTATION=ROTATION, TIME=TIME, TIME_ABSOLUTE=TIME_ABSOLUTE, VELOCITY=VELOCITY, ACCELERATION=ACCELERATION, CAMERA=CAMERA, POWER=POWER, TEMPERATURE=TEMPERATURE, WAVELENGTH=WAVELENGTH, COLOR_TEMPERATURE=COLOR_TEMPERATURE, FREQUENCY=FREQUENCY)
 """
 
 systems: typing.Any
-""" Constant value bpy.utils.units.systems(NONE='NONE', METRIC='METRIC', IMPERIAL='IMPERIAL')
+""" Constant value bpy.utils.units.systems(NONE=NONE, METRIC=METRIC, IMPERIAL=IMPERIAL)
 """

bpy_extras/anim_utils/__init__.pyi

@@ -4,6 +4,9 @@ import typing_extensions
 import numpy.typing as npt
 import bpy.types
 
+class AutoKeying:
+    """Auto-keying support.Retrieve the lock status for 4D rotation."""
+
 class BakeOptions:
     """BakeOptions(only_selected: bool, do_pose: bool, do_object: bool, do_visual_keying: bool, do_constraint_clear: bool, do_parents_clear: bool, do_clean: bool, do_location: bool, do_rotation: bool, do_scale: bool, do_bbone: bool, do_custom_props: bool)"""
 
@@ -40,30 +43,31 @@ class KeyframesCo:
         """
 
     def insert_keyframes_into_existing_action(
-        self, lookup_fcurves, total_new_keys, action, action_slot
+        self, lookup_fcurves, total_new_keys, channelbag
     ) -> None:
         """Assumes the action already exists, that it might already have F-curves. Otherwise, the
         only difference between versions is performance and implementation simplicity.
 
                 :param lookup_fcurves: : This is only used for efficiency.
-        It's a substitute for action.fcurves.find() which is a potentially expensive linear search.
+        Its a substitute for channelbag.fcurves.find() which is a potentially expensive linear search.
                 :param total_new_keys:
-                :param action:
-                :param action_slot:
+                :param channelbag:
         """
 
     def insert_keyframes_into_new_action(
-        self, total_new_keys, action, action_group_name: str
+        self, total_new_keys, channelbag, group_name
     ) -> None:
         """Assumes the action is new, that it has no F-curves. Otherwise, the only difference between versions is
         performance and implementation simplicity.
 
                 :param total_new_keys:
-                :param action:
-                :param action_group_name: Name of Action Group that F-curves are added to.
-                :type action_group_name: str
+                :param channelbag:
+                :param group_name: Name of the Group that F-curves are added to.
         """
 
+def action_ensure_channelbag_for_slot(action, slot) -> None:
+    """Ensure a layer and a keyframe strip exists, then ensure that strip has a channelbag for the slot."""
+
 def action_get_channelbag_for_slot(action, slot) -> None:
     """Returns the first channelbag found for the slot.
     In case there are multiple layers or strips they are iterated until a
@@ -71,21 +75,29 @@ def action_get_channelbag_for_slot(action, slot) -> None:
 
     """
 
+def action_get_first_suitable_slot(action, target_id_type) -> None:
+    """Return the first Slot of the given Action thats suitable for the given ID type.Typically you should not need this function; when an Action is assigned to a
+    data-block, just use the slot that was assigned along with it.
+
+    """
+
+def animdata_get_channelbag_for_assigned_slot(anim_data) -> None:
+    """Return the channelbag used in the given anim_data or None if there is no Action
+    + Slot combination defined.
+
+    """
+
 def bake_action(
     obj: bpy.types.Object, *, action: None | bpy.types.Action, frames: int, bake_options
 ) -> None | bpy.types.Action:
     """
 
         :param obj: Object to bake.
-        :type obj: bpy.types.Object
         :param action: An action to bake the data into, or None for a new action
     to be created.
-        :type action: None | bpy.types.Action
         :param frames: Frames to bake.
-        :type frames: int
         :param bake_options: Options for baking.
         :return: Action or None.
-        :rtype: None | bpy.types.Action
     """
 
 def bake_action_iter(
@@ -94,13 +106,10 @@ def bake_action_iter(
     """An coroutine that bakes action for a single object.
 
         :param obj: Object to bake.
-        :type obj: bpy.types.Object
         :param action: An action to bake the data into, or None for a new action
     to be created.
-        :type action: None | bpy.types.Action
         :param bake_options: Boolean options of what to include into the action bake.
         :return: an action or None
-        :rtype: bpy.types.Action
     """
 
 def bake_action_objects(
@@ -111,7 +120,6 @@ def bake_action_objects(
     :param frames: Frames to bake.
     :param bake_options: Options for baking.
     :return: A sequence of Action or None types (aligned with object_action_pairs)
-    :rtype: collections.abc.Sequence[bpy.types.Action]
     """
 
 def bake_action_objects_iter(object_action_pairs, bake_options) -> None:

bpy_extras/bmesh_utils/__init__.pyi

@@ -9,7 +9,6 @@ def bmesh_linked_uv_islands(bm, uv_layer) -> list[list[int]]:
     :param bm: the bmesh used to group with.
     :param uv_layer: the UV layer to source UVs from.
     :return: list of lists containing polygon indices
-    :rtype: list[list[int]]
     """
 
 def match_uv(face, vert, uv, uv_layer) -> None: ...

bpy_extras/id_map_utils/__init__.pyi

@@ -2,12 +2,20 @@ import typing
 import collections.abc
 import typing_extensions
 import numpy.typing as npt
+import bpy.types
 
-def get_all_referenced_ids(id, ref_map) -> None:
-    """Return a set of IDs directly or indirectly referenced by id."""
+def get_all_referenced_ids(
+    id: bpy.types.ID, ref_map: dict[bpy.types.ID, set[bpy.types.ID]]
+) -> set[bpy.types.ID]:
+    """Return a set of IDs directly or indirectly referenced by id.
 
-def get_id_reference_map() -> None:
-    """Return a dictionary of direct datablock references for every datablock in the blend file."""
+    :param id: Datablock whose references were interested in.
+    :param ref_map: The global ID reference map, retrieved from get_id_reference_map()
+    :return: Set of datablocks referenced by id.
+    """
 
-def recursive_get_referenced_ids(ref_map, id, referenced_ids, visited) -> None:
-    """Recursively populate referenced_ids with IDs referenced by id."""
+def get_id_reference_map() -> dict[bpy.types.ID, set[bpy.types.ID]]:
+    """Return a dictionary of direct data-block references for every data-block in the blend file.
+
+    :return: Each datablock of the .blend file mapped to the set of IDs they directly reference.
+    """

bpy_extras/image_utils/__init__.pyi

@@ -21,32 +21,23 @@ def load_image(
 
         :param dirname: is the directory where the image may be located - any file at
     the end will be ignored.
-        :type dirname: str
         :param place_holder: if True a new place holder image will be created.
     this is useful so later you can relink the image to its original data.
-        :type place_holder: bool
         :param recursive: If True, directories will be recursively searched.
     Be careful with this if you have files in your root directory because
     it may take a long time.
-        :type recursive: bool
         :param ncase_cmp: on non windows systems, find the correct case for the file.
-        :type ncase_cmp: bool
         :param convert_callback: a function that takes an existing path and returns
     a new one. Use this when loading image formats blender may not support,
     the CONVERT_CALLBACK can take the path for a GIF (for example),
-    convert it to a PNG and return the PNG's path.
+    convert it to a PNG and return the PNGs path.
     For formats blender can read, simply return the path that is given.
-        :type convert_callback: typing.Any | None
         :param relpath: If not None, make the file relative to this path.
-        :type relpath: None | str | None
         :param check_existing: If true,
-    returns already loaded image datablock if possible
+    returns already loaded image data-block if possible
     (based on file path).
-        :type check_existing: bool
         :param force_reload: If true,
     force reloading of image (only useful when check_existing
     is also enabled).
-        :type force_reload: bool
         :return: an image or None
-        :rtype: None | bpy.types.Image
     """