fake-bpy-module 20240224__py3-none-any.whl → 20240326__py3-none-any.whl

bpy/utils/previews/__init__.pyi

@@ -18,50 +18,136 @@ class ImagePreviewCollection:
 
     def load(
         self,
-        name: typing.Optional[str],
-        filepath: typing.Optional[typing.Union[bytes, str]],
-        filetype: typing.Optional[str],
-        force_reload: typing.Optional[bool] = False,
-    ) -> "bpy.types.ImagePreview":
+        name: str,
+        filepath: typing.Union[str, bytes],
+        filetype: str,
+        force_reload: bool = False,
+    ) -> bool:
         """Generate a new preview from given file path.
 
         :param name: The name (unique id) identifying the preview.
-        :type name: typing.Optional[str]
+        :type name: str
         :param filepath: The file path to generate the preview from.
-        :type filepath: typing.Optional[typing.Union[bytes, str]]
+        :type filepath: typing.Union[str, bytes]
         :param filetype: The type of file, needed to generate the preview in ['IMAGE', 'MOVIE', 'BLEND', 'FONT'].
-        :type filetype: typing.Optional[str]
+        :type filetype: str
         :param force_reload: If True, force running thumbnail manager even if preview already exists in cache.
-        :type force_reload: typing.Optional[bool]
-        :rtype: 'bpy.types.ImagePreview'
+        :type force_reload: bool
         :return: The Preview matching given name, or a new empty one.
+        :rtype: bpy.types.ImagePreview
         """
         ...
 
-    def new(self, name: typing.Optional[str]) -> "bpy.types.ImagePreview":
+    def new(self, name: str) -> str:
         """Generate a new empty preview.
 
         :param name: The name (unique id) identifying the preview.
-        :type name: typing.Optional[str]
-        :rtype: 'bpy.types.ImagePreview'
+        :type name: str
         :return: The Preview matching given name, or a new empty one.
+        :rtype: bpy.types.ImagePreview
         """
         ...
 
-def new() -> "ImagePreviewCollection":
+class ImagePreviewCollection:
+    """ """
+
+    def clear(self):
+        """ """
+        ...
+
+    def close(self):
+        """ """
+        ...
+
+    def copy(self):
+        """ """
+        ...
+
+    def fromkeys(self):
+        """ """
+        ...
+
+    def get(self, key, default):
+        """
+
+        :param key:
+        :param default:
+        """
+        ...
+
+    def items(self):
+        """ """
+        ...
+
+    def keys(self):
+        """ """
+        ...
+
+    def load(self, name, path, path_type, force_reload):
+        """
+
+        :param name:
+        :param path:
+        :param path_type:
+        :param force_reload:
+        """
+        ...
+
+    def new(self, name):
+        """
+
+        :param name:
+        """
+        ...
+
+    def pop(self):
+        """ """
+        ...
+
+    def popitem(self):
+        """ """
+        ...
+
+    def setdefault(self, key, default):
+        """
+
+        :param key:
+        :param default:
+        """
+        ...
+
+    def update(self):
+        """ """
+        ...
+
+    def values(self):
+        """ """
+        ...
+
+def new() -> ImagePreviewCollection:
     """
 
-    :rtype: 'ImagePreviewCollection'
     :return: a new preview collection.
+    :rtype: ImagePreviewCollection
     """
 
     ...
 
-def remove(pcoll: typing.Optional["ImagePreviewCollection"]):
+def new():
+    """ """
+
+    ...
+
+def remove(pcoll: ImagePreviewCollection):
     """Remove the specified previews collection.
 
     :param pcoll: Preview collection to close.
-    :type pcoll: typing.Optional['ImagePreviewCollection']
+    :type pcoll: ImagePreviewCollection
     """
 
     ...
+
+def remove(pcoll):
+    """ """
+
+    ...

bpy/utils/units/__init__.pyi

@@ -3,53 +3,50 @@ 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,
+    unit_category: str,
+    value: float,
+    precision: int = 3,
+    split_unit: bool = False,
+    compatible_unit: bool = 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
         :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
         :param value: The value to convert to a string.
-        :type value: typing.Optional[float]
+        :type value: float
         :param precision: Number of digits after the comma.
-        :type precision: typing.Optional[int]
+        :type precision: int
         :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
         :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer utf-8 ones (1m²).
-        :type compatible_unit: typing.Optional[bool]
-        :rtype: str
+        :type compatible_unit: bool
         :return: The converted string.
+        :rtype: str
     """
 
     ...
 
 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, unit_category: str, str_input: str, str_ref_unit: str = 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
         :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
         :param str_input: The string to convert to a float value.
-        :type str_input: typing.Optional[str]
+        :type str_input: str
         :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]
-        :rtype: float
+        :type str_ref_unit: str
         :return: The converted/interpreted value.
+        :rtype: float
     """
 
     ...

bpy_extras/__init__.pyi

@@ -1,17 +1,13 @@
 import typing
 from . import anim_utils
 from . import asset_utils
-from . import bmesh_utils
-from . import extensions
 from . import id_map_utils
 from . import image_utils
 from . import io_utils
 from . import keyconfig_utils
 from . import mesh_utils
-from . import node_shader_utils
 from . import node_utils
 from . import object_utils
 from . import view3d_utils
-from . import wm_utils
 
 GenericType = typing.TypeVar("GenericType")

bpy_extras/anim_utils/__init__.pyi

@@ -3,88 +3,53 @@ import bpy.types
 
 GenericType = typing.TypeVar("GenericType")
 
-class BakeOptions: ...
-
-class KeyframesCo:
-    keyframes_from_fcurve: typing.Any
-
-    def add_paths(self, rna_path, total_indices): ...
-    def extend_co_value(self, rna_path, frame, value): ...
-    def extend_co_values(self, rna_path, total_indices, frame, values): ...
-    def insert_keyframes_into_existing_action(
-        self, lookup_fcurves, total_new_keys, action, action_group_name
-    ): ...
-    def insert_keyframes_into_new_action(
-        self, total_new_keys, action, action_group_name
-    ): ...
-
 def bake_action(
-    obj: "bpy.types.Object",
-    *,
-    action: typing.Optional["bpy.types.Action"],
-    frames: int,
-    bake_options,
-) -> "bpy.types.Action":
+    obj: bpy.types.Object, action, frames, bake_options
+) -> bpy.types.Action:
     """
 
         :param obj: Object to bake.
-        :type obj: 'bpy.types.Object'
+        :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']
         :param frames: Frames to bake.
-        :type frames: int
-        :rtype: 'bpy.types.Action'
         :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: typing.Any,
-) -> "bpy.types.Action":
+def bake_action_iter(obj: bpy.types.Object, action, bake_options) -> bpy.types.Action:
     """An coroutine that bakes action for a single object.
 
         :param obj: Object to bake.
-        :type obj: 'bpy.types.Object'
+        :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']
         :param bake_options: Boolean options of what to include into the action bake.
-        :type bake_options: typing.Any
-        :rtype: 'bpy.types.Action'
         :return: an action or None
+        :rtype: bpy.types.Action
     """
 
     ...
 
 def bake_action_objects(
-    object_action_pairs, *, frames: int, bake_options
-) -> typing.Iterable["bpy.types.Action"]:
+    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.
-    :type frames: int
-    :rtype: typing.Iterable['bpy.types.Action']
     :return: A sequence of Action or None types (aligned with object_action_pairs)
+    :rtype: typing.Iterable[bpy.types.Action]
     """
 
     ...
 
-def bake_action_objects_iter(
-    object_action_pairs: typing.Union[
-        "bpy.types.Action", "bpy.types.Object", "bpy.types.Sequence"
-    ],
-    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.
-        :type object_action_pairs: typing.Union['bpy.types.Action', 'bpy.types.Object', 'bpy.types.Sequence']
     """
 
     ...

bpy_extras/asset_utils/__init__.pyi

@@ -2,16 +2,7 @@ import typing
 
 GenericType = typing.TypeVar("GenericType")
 
-class AssetBrowserPanel:
-    bl_space_type: typing.Any
+class SpaceAssetInfo:
+    """ """
 
-    def asset_browser_panel_poll(self, context): ...
-    def poll(self, context): ...
-
-class AssetMetaDataPanel:
-    bl_region_type: typing.Any
-    bl_space_type: typing.Any
-
-    def poll(self, context): ...
-
-class SpaceAssetInfo: ...
+    ...

bpy_extras/id_map_utils/__init__.pyi

@@ -11,5 +11,3 @@ 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): ...

bpy_extras/image_utils/__init__.pyi

@@ -14,7 +14,7 @@ def load_image(
     relpath: str = None,
     check_existing: bool = False,
     force_reload: bool = False,
-) -> "bpy.types.Image":
+) -> bpy.types.Image:
     """Return an image from the file path with options to search multiple paths
     and return a placeholder if its not found.
 
@@ -46,8 +46,8 @@ def load_image(
     force reloading of image (only useful when check_existing
     is also enabled).
         :type force_reload: bool
-        :rtype: 'bpy.types.Image'
         :return: an image or None
+        :rtype: bpy.types.Image
     """
 
     ...

bpy_extras/io_utils/__init__.pyi

@@ -4,11 +4,12 @@ import bpy.types
 GenericType = typing.TypeVar("GenericType")
 
 class ExportHelper:
+    """ """
+
     def check(self, _context):
         """
 
         :param _context:
-        :type _context:
         """
         ...
 
@@ -16,18 +17,17 @@ class ExportHelper:
         """
 
         :param context:
-        :type context:
         :param _event:
-        :type _event:
         """
         ...
 
 class ImportHelper:
+    """ """
+
     def check(self, _context):
         """
 
         :param _context:
-        :type _context:
         """
         ...
 
@@ -35,9 +35,7 @@ class ImportHelper:
         """
 
         :param context:
-        :type context:
         :param _event:
-        :type _event:
         """
         ...
 
@@ -50,35 +48,35 @@ def axis_conversion(from_forward="Y", from_up="Z", to_forward="Y", to_up="Z"):
     ...
 
 def axis_conversion_ensure(
-    operator: "bpy.types.Operator", forward_attr: str, up_attr: str
+    operator: bpy.types.Operator, forward_attr: str, up_attr: str
 ) -> bool:
     """Function to ensure an operator has valid axis conversion settings, intended
     to be used from `bpy.types.Operator.check`.
 
         :param operator: the operator to access axis attributes from.
-        :type operator: 'bpy.types.Operator'
+        :type operator: bpy.types.Operator
         :param forward_attr: attribute storing the forward axis
         :type forward_attr: str
         :param up_attr: attribute storing the up axis
         :type up_attr: str
-        :rtype: bool
         :return: True if the value was modified.
+        :rtype: bool
     """
 
     ...
 
 def create_derived_objects(
-    depsgraph: "bpy.types.Depsgraph", objects: typing.Iterable["bpy.types.Object"]
-) -> typing.Dict:
+    depsgraph: bpy.types.Depsgraph, objects: typing.Iterable[bpy.types.Object]
+) -> dict:
     """This function takes a sequence of objects, returning their instances.
 
         :param depsgraph: The evaluated depsgraph.
-        :type depsgraph: 'bpy.types.Depsgraph'
+        :type depsgraph: bpy.types.Depsgraph
         :param objects: A sequencer of objects.
-        :type objects: typing.Iterable['bpy.types.Object']
-        :rtype: typing.Dict
+        :type objects: typing.Iterable[bpy.types.Object]
         :return: A dictionary where each key is an object from objects,
     values are lists of (`bpy.types.Object`, `mathutils.Matrix`) tuples representing instances.
+        :rtype: dict
     """
 
     ...
@@ -97,8 +95,8 @@ def path_reference(
     base_dst: str,
     mode: str = "AUTO",
     copy_subdir: str = "",
-    copy_set: typing.Set = None,
-    library: typing.Optional["bpy.types.Library"] = None,
+    copy_set: set = None,
+    library=None,
 ) -> str:
     """Return a filepath relative to a destination directory, for use with
     exporters.
@@ -119,20 +117,19 @@ def path_reference(
         :type copy_subdir: str
         :param copy_set: collect from/to pairs when mode='COPY',
     pass to path_reference_copy when exporting is done.
-        :type copy_set: typing.Set
+        :type copy_set: set
         :param library: The library this path is relative to.
-        :type library: typing.Optional['bpy.types.Library']
-        :rtype: str
         :return: the new filepath.
+        :rtype: str
     """
 
     ...
 
-def path_reference_copy(copy_set: typing.Set, report: typing.Any = None):
+def path_reference_copy(copy_set: set, report: typing.Any = None):
     """Execute copying files of path_reference
 
     :param copy_set: set of (from, to) pairs to copy.
-    :type copy_set: typing.Set
+    :type copy_set: set
     :param report: function used for reporting warnings, takes a string argument.
     :type report: typing.Any
     """
@@ -140,9 +137,9 @@ def path_reference_copy(copy_set: typing.Set, report: typing.Any = None):
     ...
 
 def unique_name(
-    key: typing.Any,
+    key,
     name: str,
-    name_dict: typing.Dict,
+    name_dict: dict,
     name_max=-1,
     clean_func: typing.Any = None,
     sep: str = ".",
@@ -153,13 +150,12 @@ def unique_name(
         :param key: unique item this name belongs to, name_dict[key] will be reused
     when available.
     This can be the object, mesh, material, etc instance itself.
-        :type key: typing.Any
         :param name: The name used to create a unique value in name_dict.
         :type name: str
         :param name_dict: This is used to cache namespace to ensure no collisions
     occur, this should be an empty dict initially and only modified by this
     function.
-        :type name_dict: typing.Dict
+        :type name_dict: dict
         :param clean_func: Function to call on name before creating a unique value.
         :type clean_func: typing.Any
         :param sep: Separator to use when between the name and a number when a
@@ -169,5 +165,12 @@ def unique_name(
 
     ...
 
-def unpack_face_list(list_of_tuples): ...
-def unpack_list(list_of_tuples): ...
+def unpack_face_list(list_of_tuples):
+    """ """
+
+    ...
+
+def unpack_list(list_of_tuples):
+    """ """
+
+    ...

bpy_extras/keyconfig_utils/__init__.pyi

@@ -12,4 +12,7 @@ def addon_keymap_unregister(keymap_data):
 
     ...
 
-def keyconfig_test(kc): ...
+def keyconfig_test(kc):
+    """ """
+
+    ...

bpy_extras/mesh_utils/__init__.pyi

@@ -3,21 +3,21 @@ import bpy.types
 
 GenericType = typing.TypeVar("GenericType")
 
-def edge_face_count(mesh) -> typing.List:
+def edge_face_count(mesh) -> list:
     """
 
-    :rtype: typing.List
     :return: list face users for each item in mesh.edges.
+    :rtype: list
     """
 
     ...
 
-def edge_face_count_dict(mesh) -> typing.Dict:
+def edge_face_count_dict(mesh) -> dict:
     """
 
-        :rtype: typing.Dict
         :return: dict of edge keys with their value set to the number of
     faces using each edge.
+        :rtype: dict
     """
 
     ...
@@ -30,32 +30,32 @@ def edge_loops_from_edges(mesh, edges=None):
 
     ...
 
-def mesh_linked_triangles(mesh: "bpy.types.Mesh") -> typing.List:
+def mesh_linked_triangles(mesh: bpy.types.Mesh) -> list:
     """Splits the mesh into connected triangles, use this for separating cubes from
     other mesh elements within 1 mesh datablock.
 
         :param mesh: the mesh used to group with.
-        :type mesh: 'bpy.types.Mesh'
-        :rtype: typing.List
+        :type mesh: bpy.types.Mesh
         :return: lists of lists containing triangles.
+        :rtype: list
     """
 
     ...
 
-def mesh_linked_uv_islands(mesh: "bpy.types.Mesh") -> typing.List:
+def mesh_linked_uv_islands(mesh: bpy.types.Mesh) -> list:
     """Returns lists of polygon indices connected by UV islands.
 
     :param mesh: the mesh used to group with.
-    :type mesh: 'bpy.types.Mesh'
-    :rtype: typing.List
+    :type mesh: bpy.types.Mesh
     :return: list of lists containing polygon indices
+    :rtype: list
     """
 
     ...
 
 def ngon_tessellate(
-    from_data: typing.Union["bpy.types.Mesh", typing.List],
-    indices: typing.List,
+    from_data: typing.Union[list, bpy.types.Mesh],
+    indices: list,
     fix_loops: bool = True,
     debug_print=True,
 ):
@@ -64,11 +64,11 @@ def ngon_tessellate(
     ngon to create from existing verts.
 
         :param from_data: either a mesh, or a list/tuple of vectors.
-        :type from_data: typing.Union['bpy.types.Mesh', typing.List]
+        :type from_data: typing.Union[list, bpy.types.Mesh]
         :param indices: a list of indices to use this list
     is the ordered closed poly-line
     to fill, and can be a subset of the data given.
-        :type indices: typing.List
+        :type indices: list
         :param fix_loops: If this is enabled poly-lines
     that use loops to make multiple
     poly-lines are dealt with correctly.
@@ -79,15 +79,15 @@ def ngon_tessellate(
 
 def triangle_random_points(
     num_points,
-    loop_triangles: typing.Union["bpy.types.MeshLoopTriangle", typing.Sequence],
-) -> typing.List:
+    loop_triangles: typing.Union[bpy.types.MeshLoopTriangle, typing.Sequence],
+) -> list:
     """Generates a list of random points over mesh loop triangles.
 
     :param num_points: the number of random points to generate on each triangle.
     :param loop_triangles: list of the triangles to generate points on.
-    :type loop_triangles: typing.Union['bpy.types.MeshLoopTriangle', typing.Sequence]
-    :rtype: typing.List
+    :type loop_triangles: typing.Union[bpy.types.MeshLoopTriangle, typing.Sequence]
     :return: list of random points over all triangles.
+    :rtype: list
     """
 
     ...

bpy_extras/node_utils/__init__.pyi

@@ -2,6 +2,7 @@ import typing
 
 GenericType = typing.TypeVar("GenericType")
 
-def connect_sockets(input, output): ...
-def find_base_socket_type(socket): ...
-def find_node_input(node, name): ...
+def find_node_input(node, name):
+    """ """
+
+    ...