fake-bpy-module 20241103__py3-none-any.whl → 20241111__py3-none-any.whl

bpy/utils/__init__.pyi

@@ -13,6 +13,8 @@ bpy.utils.units.rst
 import typing
 import collections.abc
 import typing_extensions
+import bpy.types
+
 from . import previews as previews
 from . import units as units
 
@@ -21,12 +23,10 @@ def app_template_paths(*, path: str | None = None):
 
     :param path: Optional subdir.
     :type path: str | None
-    :return: app template paths.
+    :return: App template paths.
     """
 
-def blend_paths(
-    absolute: bool = False, packed: bool = False, local: bool = False
-) -> list[str]:
+def blend_paths(absolute: bool = False, packed: bool = False, local: bool = False):
     """Returns a list of paths to external files referenced by the loaded .blend file.
 
     :param absolute: When true the paths returned are made absolute.
@@ -36,7 +36,6 @@ def blend_paths(
     :param local: When true skip linked library paths.
     :type local: bool
     :return: path list.
-    :rtype: list[str]
     """
 
 def escape_identifier(string: str) -> str:
@@ -126,7 +125,7 @@ def load_scripts_extensions(*, reload_scripts: bool = False):
         :type reload_scripts: bool
     """
 
-def make_rna_paths(struct_name: str, prop_name: str, enum_name: str):
+def make_rna_paths(struct_name: str, prop_name: str, enum_name: str) -> str:
     """Create RNA "paths" from given names.
 
         :param struct_name: Name of a RNA struct (like e.g. "Scene").
@@ -138,6 +137,7 @@ def make_rna_paths(struct_name: str, prop_name: str, enum_name: str):
         :return: A triple of three "RNA paths"
     (most_complete_path, "struct.prop", "struct.prop:'enum'").
     If no enum_name is given, the third element will always be void.
+        :rtype: str
     """
 
 def manual_language_code(default="en") -> str:
@@ -149,32 +149,29 @@ def manual_language_code(default="en") -> str:
     """
 
 def manual_map(): ...
-def modules_from_path(path: str, loaded_modules: set) -> list:
+def modules_from_path(path: str, loaded_modules):
     """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.
-        :type loaded_modules: set
         :return: all loaded modules.
-        :rtype: list
     """
 
 def preset_find(name, preset_path, *, display_name=False, ext=".py"): ...
-def preset_paths(subdir: str) -> list:
+def preset_paths(subdir: 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
+    :return: Script paths.
     """
 
 def refresh_script_paths():
     """Run this after creating new script paths to update sys.path"""
 
-def register_class(cls):
+def register_class(cls: typing.Any):
     """Register a subclass of a Blender type class.
 
         :param cls: Blender type class in:
@@ -183,6 +180,7 @@ def register_class(cls):
     `bpy.types.Operator`, `bpy.types.KeyingSetInfo`,
     `bpy.types.RenderEngine`, `bpy.types.AssetShelf`,
     `bpy.types.FileHandler`
+        :type cls: typing.Any
     """
 
 def register_classes_factory(classes):
@@ -224,7 +222,9 @@ def register_preset_path(path: str) -> bool:
         :rtype: bool
     """
 
-def register_submodule_factory(module_name: str, submodule_names: list[str]):
+def register_submodule_factory(
+    module_name: str, submodule_names
+) -> collections.abc.Callable:
     """Utility function to create register and unregister functions
     which simply load submodules,
     calling their register & unregister functions.
@@ -232,16 +232,21 @@ def register_submodule_factory(module_name: str, submodule_names: list[str]):
         :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: collections.abc.Callable
     """
 
 def register_tool(
-    tool_cls, *, after=None, separator: bool = False, group: bool = False
+    tool_cls: bpy.types.WorkSpaceTool,
+    *,
+    after=None,
+    separator: bool = False,
+    group: bool = False,
 ):
     """Register a tool in the toolbar.
 
     :param tool_cls: A tool subclass.
+    :type tool_cls: bpy.types.WorkSpaceTool
     :param after: Optional identifiers this tool will be added after.
     :param separator: When true, add a separator before this tool.
     :type separator: bool
@@ -274,7 +279,7 @@ def script_paths(
     check_all: bool = False,
     use_user: bool = True,
     use_system_environment: bool = True,
-) -> list:
+):
     """Returns a list of valid script paths.
 
     :param subdir: Optional subdir.
@@ -288,7 +293,6 @@ def script_paths(
     :param use_system_environment: Include BLENDER_SYSTEM_SCRIPTS variable path
     :type use_system_environment: bool
     :return: script paths.
-    :rtype: list
     """
 
 def script_paths_pref():
@@ -297,46 +301,42 @@ def script_paths_pref():
 def script_paths_system_environment():
     """Returns a list of system script directories from environment variables."""
 
-def smpte_from_frame(frame: int, *, fps=None, fps_base=None) -> str:
+def smpte_from_frame(frame, *, fps=None, fps_base=None) -> str:
     """Returns an SMPTE formatted string from the frame:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param frame: frame number.
-        :type frame: int
         :return: the frame string.
         :rtype: str
     """
 
-def smpte_from_seconds(time: float, *, fps=None, fps_base=None) -> str:
+def smpte_from_seconds(time, *, fps=None, fps_base=None) -> str:
     """Returns an SMPTE formatted string from the time:
     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: int, *, fps=None, fps_base=None):
+def time_from_frame(frame, *, fps=None, fps_base=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: int
     :return: the time in seconds.
     """
 
-def time_to_frame(time, *, fps=None, fps_base=None) -> float:
+def time_to_frame(time, *, fps=None, fps_base=None):
     """Returns a float frame number from a time given in seconds or
     as a datetime.timedelta object.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
-        :return: the frame.
-        :rtype: float
+        :return: The frame.
     """
 
 def unescape_identifier(string: str) -> str:
     """Simple string un-escape function used for animation paths.
-    This performs the reverse of escape_identifier.
+    This performs the reverse of `escape_identifier`.
 
         :param string: text
         :type string: str
@@ -344,12 +344,13 @@ def unescape_identifier(string: str) -> str:
         :rtype: str
     """
 
-def unregister_class(cls):
+def unregister_class(cls: typing.Any):
     """Unload the Python class from blender.
 
         :param cls: Blender type class,
     see `bpy.utils.register_class` for classes which can
     be registered.
+        :type cls: typing.Any
     """
 
 def unregister_cli_command(handle):

bpy/utils/previews/__init__.pyi

@@ -32,7 +32,7 @@ class ImagePreviewCollection:
     def load(
         self,
         name: str | None,
-        filepath: bytes | str | None,
+        filepath,
         filetype: str | None,
         force_reload: bool | None = False,
     ) -> bpy.types.ImagePreview:
@@ -41,7 +41,6 @@ class ImagePreviewCollection:
         :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 force_reload: If True, force running thumbnail manager even if preview already exists in cache.

bpy/utils/units/__init__.pyi

@@ -38,7 +38,7 @@ def to_value(
     unit_system: str | None,
     unit_category: str | None,
     str_input: str | None,
-    str_ref_unit: str | None = None,
+    str_ref_unit=None,
 ) -> float:
     """Convert a given input string into a float value.
 
@@ -50,7 +50,6 @@ def to_value(
         :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: str | None
         :return: The converted/interpreted value.
         :rtype: float
     """

bpy_extras/anim_utils/__init__.pyi

@@ -63,24 +63,21 @@ class KeyframesCo:
                 :type action_group_name: str
         """
 
-def bake_action(
-    obj: bpy.types.Object, *, action: bpy.types.Action | None, frames, bake_options
-) -> bpy.types.Action:
+def bake_action(obj: bpy.types.Object, *, action, frames: int, bake_options):
     """
 
         :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.
+        :type frames: int
         :param bake_options: Options for baking.
-        :return: an action or None
-        :rtype: bpy.types.Action
+        :return: Action or None.
     """
 
 def bake_action_iter(
-    obj: bpy.types.Object, *, action: bpy.types.Action | None, bake_options
+    obj: bpy.types.Object, *, action, bake_options
 ) -> bpy.types.Action:
     """An coroutine that bakes action for a single object.
 
@@ -88,21 +85,17 @@ 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: 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
     """
 
-def bake_action_objects(
-    object_action_pairs, *, frames, bake_options
-) -> list[bpy.types.Action]:
+def bake_action_objects(object_action_pairs, *, frames, bake_options):
     """A version of `bake_action_objects_iter` that takes frames and returns the output.
 
     :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: list[bpy.types.Action]
     """
 
 def bake_action_objects_iter(object_action_pairs, bake_options):

bpy_extras/bmesh_utils/__init__.pyi

@@ -2,13 +2,12 @@ import typing
 import collections.abc
 import typing_extensions
 
-def bmesh_linked_uv_islands(bm, uv_layer) -> list:
+def bmesh_linked_uv_islands(bm, uv_layer):
     """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
     """
 
 def match_uv(face, vert, uv, uv_layer): ...

bpy_extras/image_utils/__init__.pyi

@@ -1,7 +1,6 @@
 import typing
 import collections.abc
 import typing_extensions
-import bpy.types
 
 def load_image(
     imagepath,
@@ -11,10 +10,10 @@ def load_image(
     ncase_cmp: bool = True,
     convert_callback: typing.Any | None = None,
     verbose=False,
-    relpath: str | None = None,
+    relpath=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.
 
@@ -37,7 +36,6 @@ def load_image(
     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: str | None
         :param check_existing: If true,
     returns already loaded image datablock if possible
     (based on file path).
@@ -47,5 +45,4 @@ def load_image(
     is also enabled).
         :type force_reload: bool
         :return: an image or None
-        :rtype: bpy.types.Image
     """

bpy_extras/io_utils/__init__.pyi

@@ -60,18 +60,14 @@ def axis_conversion_ensure(
         :rtype: bool
     """
 
-def create_derived_objects(
-    depsgraph: bpy.types.Depsgraph, objects: list[bpy.types.Object]
-) -> dict:
+def create_derived_objects(depsgraph: bpy.types.Depsgraph, objects):
     """This function takes a sequence of objects, returning their instances.
 
         :param depsgraph: The evaluated depsgraph.
         :type depsgraph: bpy.types.Depsgraph
         :param objects: A sequencer of objects.
-        :type objects: list[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
+    values are lists of (object, matrix) tuples representing instances.
     """
 
 def orientation_helper(axis_forward="Y", axis_up="Z"):
@@ -86,8 +82,8 @@ def path_reference(
     base_dst: str,
     mode: str = "AUTO",
     copy_subdir: str = "",
-    copy_set: set | None = None,
-    library: bpy.types.Library | None = None,
+    copy_set=None,
+    library=None,
 ) -> str:
     """Return a filepath relative to a destination directory, for use with
     exporters.
@@ -108,20 +104,17 @@ 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: set | None
         :param library: The library this path is relative to.
-        :type library: bpy.types.Library | None
         :return: the new filepath.
         :rtype: str
     """
 
-def path_reference_copy(copy_set: set, report: typing.Any = print):
+def path_reference_copy(copy_set, report: collections.abc.Callable = print):
     """Execute copying files of path_reference
 
     :param copy_set: set of (from, to) pairs to copy.
-    :type copy_set: set
     :param report: function used for reporting warnings, takes a string argument.
-    :type report: typing.Any
+    :type report: collections.abc.Callable
     """
 
 def poll_file_object_drop(context):
@@ -141,9 +134,10 @@ def unique_name(
     """Helper function for storing unique names which may have special characters
     stripped and restricted to a maximum length.
 
-        :param key: unique item this name belongs to, name_dict[key] will be reused
+        :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.
+    Any hashable object associated with the name.
         :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

bpy_extras/mesh_utils/__init__.pyi

@@ -3,19 +3,16 @@ import collections.abc
 import typing_extensions
 import bpy.types
 
-def edge_face_count(mesh) -> list:
+def edge_face_count(mesh):
     """
 
     :return: list face users for each item in mesh.edges.
-    :rtype: list
     """
 
-def edge_face_count_dict(mesh) -> dict:
+def edge_face_count_dict(mesh):
     """
 
-        :return: dict of edge keys with their value set to the number of
-    faces using each edge.
-        :rtype: dict
+    :return: Dictionary of edge keys with their value set to the number of faces using each edge.
     """
 
 def edge_loops_from_edges(mesh, edges=None):
@@ -24,55 +21,43 @@ def edge_loops_from_edges(mesh, edges=None):
 
     """
 
-def mesh_linked_triangles(mesh: bpy.types.Mesh) -> list:
+def mesh_linked_triangles(mesh: bpy.types.Mesh):
     """Splits the mesh into connected triangles, use this for separating cubes from
-    other mesh elements within 1 mesh datablock.
+    other mesh elements within 1 mesh data-block.
 
         :param mesh: the mesh used to group with.
         :type mesh: bpy.types.Mesh
-        :return: lists of lists containing triangles.
-        :rtype: list
+        :return: Lists of lists containing triangles.
     """
 
-def mesh_linked_uv_islands(mesh: bpy.types.Mesh) -> list:
+def mesh_linked_uv_islands(mesh: bpy.types.Mesh):
     """Returns lists of polygon indices connected by UV islands.
 
     :param mesh: the mesh used to group with.
     :type mesh: bpy.types.Mesh
     :return: list of lists containing polygon indices
-    :rtype: list
     """
 
-def ngon_tessellate(
-    from_data: bpy.types.Mesh | list,
-    indices: list,
-    fix_loops: bool = True,
-    debug_print=True,
-):
+def ngon_tessellate(from_data, indices, fix_loops: bool = True, debug_print=True):
     """Takes a poly-line of indices (ngon) and returns a list of face
     index lists. Designed to be used for importers that need indices for an
     ngon to create from existing verts.
 
-        :param from_data: either a mesh, or a list/tuple of vectors.
-        :type from_data: bpy.types.Mesh | list
+        :param from_data: Either a mesh, or a list/tuple of 3D vectors.
         :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: list
         :param fix_loops: If this is enabled poly-lines
     that use loops to make multiple
     poly-lines are dealt with correctly.
         :type fix_loops: bool
     """
 
-def triangle_random_points(
-    num_points, loop_triangles: bpy.types.MeshLoopTriangle | collections.abc.Sequence
-) -> list:
+def triangle_random_points(num_points: int, loop_triangles):
     """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: bpy.types.MeshLoopTriangle | collections.abc.Sequence
-    :return: list of random points over all triangles.
-    :rtype: list
+    :param num_points: The number of random points to generate on each triangle.
+    :type num_points: int
+    :param loop_triangles: Sequence of the triangles to generate points on.
+    :return: List of random points over all triangles.
     """

bpy_extras/object_utils/__init__.pyi

@@ -44,7 +44,7 @@ def object_data_add(
 
         :param context: The context to use.
         :type context: bpy.types.Context | None
-        :param obdata: the data used for the new object.
+        :param obdata: Valid object data to used for the new object or None.
         :param operator: The operator, checked for location and rotation properties.
         :type operator: bpy.types.Operator | None
         :param name: Optional name

bpy_extras/view3d_utils/__init__.pyi

@@ -10,7 +10,7 @@ def location_3d_to_region_2d(
     coord: collections.abc.Sequence[float] | mathutils.Vector,
     *,
     default=None,
-) -> mathutils.Vector:
+):
     """Return the region relative 2d location of a 3d position.
 
         :param region: region of the 3D viewport, typically bpy.context.region.
@@ -22,7 +22,6 @@ def location_3d_to_region_2d(
         :param default: Return this value if coord
     is behind the origin of a perspective view.
         :return: 2d location
-        :rtype: mathutils.Vector
     """
 
 def region_2d_to_location_3d(
@@ -49,11 +48,7 @@ def region_2d_to_location_3d(
     """
 
 def region_2d_to_origin_3d(
-    region: bpy.types.Region,
-    rv3d: bpy.types.RegionView3D,
-    coord: collections.abc.Sequence[float] | mathutils.Vector,
-    *,
-    clamp: float | None = None,
+    region: bpy.types.Region, rv3d: bpy.types.RegionView3D, coord, *, clamp=None
 ) -> mathutils.Vector:
     """Return the 3d view origin from the region relative 2d coords.
 
@@ -61,12 +56,10 @@ def region_2d_to_origin_3d(
         :type region: bpy.types.Region
         :param rv3d: 3D region data, typically bpy.context.space_data.region_3d.
         :type rv3d: bpy.types.RegionView3D
-        :param coord: 2d coordinates relative to the region;
+        :param coord: 2D coordinates relative to the region;
     (event.mouse_region_x, event.mouse_region_y) for example.
-        :type coord: collections.abc.Sequence[float] | mathutils.Vector
         :param clamp: Clamp the maximum far-clip value used.
     (negative value will move the offset away from the view_location)
-        :type clamp: float | None
         :return: The origin of the viewpoint in 3d space.
         :rtype: mathutils.Vector
     """

{fake_bpy_module-20241103.dist-info → fake_bpy_module-20241111.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fake-bpy-module
-Version: 20241103
+Version: 20241111
 Summary: Collection of the fake Blender Python API module for the code completion.
 Author: nutti
 Author-email: nutti.metro@gmail.com