fake-bpy-module 20240516__py3-none-any.whl → 20240517__py3-none-any.whl

bpy/utils/previews/__init__.pyi

@@ -19,26 +19,28 @@ import bpy.types
 GenericType = typing.TypeVar("GenericType")
 
 class ImagePreviewCollection:
-    """ """
+    """Dictionary-like class of previews.This is a subclass of Python's built-in dict type,
+    used to store multiple image previews.
+    """
 
     def clear(self):
-        """ """
+        """Clear all previews."""
         ...
 
     def close(self):
-        """ """
+        """Close the collection and clear all previews."""
         ...
 
     def copy(self):
-        """ """
+        """D.copy() -> a shallow copy of D"""
         ...
 
     def fromkeys(self):
-        """ """
+        """Create a new dictionary with keys from iterable and values set to value."""
         ...
 
-    def get(self, key, default):
-        """
+    def get(self, key, default=None):
+        """Return the value for key if key is in the dictionary, else default.
 
         :param key:
         :param default:
@@ -46,40 +48,55 @@ class ImagePreviewCollection:
         ...
 
     def items(self):
-        """ """
+        """D.items() -> a set-like object providing a view on D's items"""
         ...
 
     def keys(self):
-        """ """
+        """D.keys() -> a set-like object providing a view on D's keys"""
         ...
 
-    def load(self, name, path, path_type, force_reload):
-        """
+    def load(
+        self, name: str | None, path, path_type, force_reload: bool | None = False
+    ) -> bpy.types.ImagePreview:
+        """Generate a new preview from given file path.
 
-        :param name:
+        :param name: The name (unique id) identifying the preview.
+        :type name: str | None
         :param path:
         :param path_type:
-        :param force_reload:
+        :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):
-        """
+    def new(self, name: str | None) -> bpy.types.ImagePreview:
+        """Generate a new empty preview.
 
-        :param name:
+        :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 pop(self):
-        """ """
+        """D.pop(k[,d]) -> v, remove specified key and return the corresponding value.If the key is not found, return the default if given; otherwise,
+        raise a KeyError.
+
+        """
         ...
 
     def popitem(self):
-        """ """
-        ...
+        """Remove and return a (key, value) pair as a 2-tuple.Pairs are returned in LIFO (last-in, first-out) order.
+        Raises KeyError if the dict is empty.
 
-    def setdefault(self, key, default):
         """
+        ...
+
+    def setdefault(self, key, default=None):
+        """Insert key with a value of default if key is not in the dictionary.Return the value for key if key is in the dictionary, else default.
 
         :param key:
         :param default:
@@ -87,11 +104,16 @@ class ImagePreviewCollection:
         ...
 
     def update(self):
-        """ """
+        """D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
+        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
+        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
+        In either case, this is followed by: for k in F:  D[k] = F[k]
+
+        """
         ...
 
     def values(self):
-        """ """
+        """D.values() -> an object providing a view on D's values"""
         ...
 
 def new() -> ImagePreviewCollection:
@@ -103,21 +125,29 @@ def new() -> ImagePreviewCollection:
 
     ...
 
-def new():
-    """ """
+def new() -> ImagePreviewCollection:
+    """
+
+    :return: a new preview collection.
+    :rtype: ImagePreviewCollection
+    """
 
     ...
 
-def remove(pcoll: typing.Optional[ImagePreviewCollection]):
+def remove(pcoll: ImagePreviewCollection | None):
     """Remove the specified previews collection.
 
     :param pcoll: Preview collection to close.
-    :type pcoll: typing.Optional[ImagePreviewCollection]
+    :type pcoll: ImagePreviewCollection | None
     """
 
     ...
 
-def remove(pcoll):
-    """ """
+def remove(pcoll: ImagePreviewCollection | None):
+    """Remove the specified previews collection.
+
+    :param pcoll: Preview collection to close.
+    :type pcoll: ImagePreviewCollection | None
+    """
 
     ...

bpy/utils/units/__init__.pyi

@@ -8,28 +8,28 @@ import typing
 GenericType = typing.TypeVar("GenericType")
 
 def to_string(
-    unit_system: typing.Optional[str],
-    unit_category: typing.Optional[str],
-    value: typing.Optional[float],
-    precision: typing.Optional[int] = 3,
-    split_unit: typing.Optional[bool] = False,
-    compatible_unit: typing.Optional[bool] = False,
+    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,
 ) -> str:
     """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: typing.Optional[str]
+        :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: typing.Optional[str]
+        :type unit_category: str | None
         :param value: The value to convert to a string.
-        :type value: typing.Optional[float]
+        :type value: float | None
         :param precision: Number of digits after the comma.
-        :type precision: typing.Optional[int]
+        :type precision: int | None
         :param split_unit: Whether to use several units if needed (1m1cm), or always only one (1.01m).
-        :type split_unit: typing.Optional[bool]
+        :type split_unit: bool | None
         :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer utf-8 ones (1m²).
-        :type compatible_unit: typing.Optional[bool]
+        :type compatible_unit: bool | None
         :return: The converted string.
         :rtype: str
     """
@@ -37,22 +37,22 @@ def to_string(
     ...
 
 def to_value(
-    unit_system: typing.Optional[str],
-    unit_category: typing.Optional[str],
-    str_input: typing.Optional[str],
-    str_ref_unit: typing.Optional[str] = None,
+    unit_system: str | None,
+    unit_category: str | None,
+    str_input: str | None,
+    str_ref_unit: 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: typing.Optional[str]
+        :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: typing.Optional[str]
+        :type unit_category: str | None
         :param str_input: The string to convert to a float value.
-        :type str_input: typing.Optional[str]
+        :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: typing.Optional[str]
+        :type str_ref_unit: str | None
         :return: The converted/interpreted value.
         :rtype: float
     """

bpy_extras/anim_utils/__init__.pyi

@@ -4,12 +4,15 @@ import bpy.types
 GenericType = typing.TypeVar("GenericType")
 
 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)"""
 
     ...
 
 class KeyframesCo:
-    """ """
+    """A buffer for keyframe Co unpacked values per FCurveKey. FCurveKeys are added using
+    add_paths(), Co values stored using extend_co_values(), then finally use
+    insert_keyframes_into_*_action() for efficiently inserting keys into the F-curves.Users are limited to one Action Group per instance.
+    """
 
     keyframes_from_fcurve: typing.Any
     """ """
@@ -42,33 +45,35 @@ class KeyframesCo:
         ...
 
     def insert_keyframes_into_existing_action(
-        self, lookup_fcurves, total_new_keys, action, action_group_name
+        self, lookup_fcurves, total_new_keys, action, action_group_name: str
     ):
-        """
-
-        :param lookup_fcurves:
-        :param total_new_keys:
-        :param action:
-        :param action_group_name:
+        """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.
+                :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
         """
         ...
 
     def insert_keyframes_into_new_action(
-        self, total_new_keys, action, action_group_name
+        self, total_new_keys, action, action_group_name: str
     ):
-        """
+        """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:
+                :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
         """
         ...
 
 def bake_action(
-    obj: bpy.types.Object,
-    action: typing.Optional[bpy.types.Action],
-    frames,
-    bake_options,
+    obj: bpy.types.Object, action: bpy.types.Action | None, frames, bake_options
 ) -> bpy.types.Action:
     """
 
@@ -76,7 +81,7 @@ def bake_action(
         :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: typing.Optional[bpy.types.Action]
+        :type action: bpy.types.Action | None
         :param frames: Frames to bake.
         :return: an action or None
         :rtype: bpy.types.Action
@@ -84,13 +89,25 @@ def bake_action(
 
     ...
 
-def bake_action(obj, action, frames, bake_options):
-    """ """
+def bake_action(
+    obj: bpy.types.Object, action: bpy.types.Action | None, frames, bake_options
+) -> 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: bpy.types.Action | None
+        :param frames: Frames to bake.
+        :return: an action or None
+        :rtype: bpy.types.Action
+    """
 
     ...
 
 def bake_action_iter(
-    obj: bpy.types.Object, action: typing.Optional[bpy.types.Action], bake_options
+    obj: bpy.types.Object, action: bpy.types.Action | None, bake_options
 ) -> bpy.types.Action:
     """An coroutine that bakes action for a single object.
 
@@ -98,7 +115,7 @@ def bake_action_iter(
         :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: typing.Optional[bpy.types.Action]
+        :type action: bpy.types.Action | None
         :param bake_options: Boolean options of what to include into the action bake.
         :return: an action or None
         :rtype: bpy.types.Action
@@ -106,8 +123,20 @@ def bake_action_iter(
 
     ...
 
-def bake_action_iter(obj, action, bake_options):
-    """ """
+def bake_action_iter(
+    obj: bpy.types.Object, action: bpy.types.Action | None, bake_options
+) -> bpy.types.Action:
+    """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: bpy.types.Action | None
+        :param bake_options: Boolean options of what to include into the action bake.
+        :return: an action or None
+        :rtype: bpy.types.Action
+    """
 
     ...
 
@@ -123,8 +152,15 @@ def bake_action_objects(
 
     ...
 
-def bake_action_objects(object_action_pairs, frames, bake_options):
-    """ """
+def bake_action_objects(
+    object_action_pairs, frames, bake_options
+) -> typing.Iterable[bpy.types.Action]:
+    """A version of `bake_action_objects_iter` that takes frames and returns the output.
+
+    :param frames: Frames to bake.
+    :return: A sequence of Action or None types (aligned with object_action_pairs)
+    :rtype: typing.Iterable[bpy.types.Action]
+    """
 
     ...
 
@@ -138,6 +174,10 @@ def bake_action_objects_iter(object_action_pairs, bake_options):
     ...
 
 def bake_action_objects_iter(object_action_pairs, bake_options):
-    """ """
+    """An coroutine that bakes actions for multiple objects.
+
+        :param object_action_pairs: Sequence of object action tuples,
+    action is the destination for the baked data. When None a new action will be created.
+    """
 
     ...

bpy_extras/bmesh_utils/__init__.pyi

@@ -2,8 +2,14 @@ import typing
 
 GenericType = typing.TypeVar("GenericType")
 
-def bmesh_linked_uv_islands(bm, uv_layer):
-    """ """
+def bmesh_linked_uv_islands(bm, uv_layer) -> list:
+    """Returns lists of faces connected by UV islands.For meshes use `bpy.types.Mesh.mesh_linked_uv_islands` instead.
+
+    :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
+    """
 
     ...
 

bpy_extras/extensions/junction_module/__init__.pyi

@@ -6,7 +6,7 @@ class JunctionModuleHandle:
     """ """
 
     def register_module(self):
-        """ """
+        """Register the base module in sys.modules."""
         ...
 
     def register_submodule(self, submodule_name, dirpath):
@@ -38,7 +38,10 @@ class JunctionModuleHandle:
         ...
 
     def unregister_module(self):
-        """ """
+        """Unregister the base module in sys.modules.
+        Keep everything except the modules name (allowing re-registration).
+
+        """
         ...
 
     def unregister_submodule(self, submodule_name):

bpy_extras/id_map_utils/__init__.pyi

@@ -8,7 +8,7 @@ def get_all_referenced_ids(id, ref_map):
     ...
 
 def get_all_referenced_ids(id, ref_map):
-    """ """
+    """Return a set of IDs directly or indirectly referenced by id."""
 
     ...
 
@@ -18,11 +18,11 @@ def get_id_reference_map():
     ...
 
 def get_id_reference_map():
-    """ """
+    """Return a dictionary of direct datablock references for every datablock in the blend file."""
 
     ...
 
 def recursive_get_referenced_ids(ref_map, id, referenced_ids, visited):
-    """ """
+    """Recursively populate referenced_ids with IDs referenced by id."""
 
     ...

bpy_extras/image_utils/__init__.pyi

@@ -54,16 +54,49 @@ def load_image(
 
 def load_image(
     imagepath,
-    dirname,
-    place_holder,
-    recursive,
-    ncase_cmp,
-    convert_callback,
-    verbose,
-    relpath,
-    check_existing,
-    force_reload,
-):
-    """ """
+    dirname: str = "",
+    place_holder: bool = False,
+    recursive: bool = False,
+    ncase_cmp: bool = True,
+    convert_callback: typing.Any = None,
+    verbose=False,
+    relpath: str = None,
+    check_existing: bool = False,
+    force_reload: bool = False,
+) -> bpy.types.Image:
+    """Return an image from the file path with options to search multiple paths
+    and return a placeholder if its not found.
+
+        :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.
+    For formats blender can read, simply return the path that is given.
+        :type convert_callback: typing.Any
+        :param relpath: If not None, make the file relative to this path.
+        :type relpath: str
+        :param check_existing: If true,
+    returns already loaded image datablock 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: bpy.types.Image
+    """
 
     ...