fake-bpy-module 20241103__tar.gz → 20241111__tar.gz

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/PKG-INFO

@@ -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

fake_bpy_module-20241111/addon_utils/__init__.pyi

@@ -0,0 +1,81 @@
+import typing
+import collections.abc
+import typing_extensions
+
+class _ext_global:
+    idmap_pair: typing.Any
+    module_handle: typing.Any
+
+def check(module_name: str):
+    """Returns the loaded state of the addon.
+
+    :param module_name: The name of the addon and module.
+    :type module_name: str
+    :return: (loaded_default, loaded_state)
+    """
+
+def check_extension(module_name):
+    """Return true if the module is an extension."""
+
+def disable(
+    module_name: str,
+    *,
+    default_set: bool = False,
+    refresh_handled=False,
+    handle_error: collections.abc.Callable | None = None,
+):
+    """Disables an addon by name.
+
+    :param module_name: The name of the addon and module.
+    :type module_name: str
+    :param default_set: Set the user-preference.
+    :type default_set: bool
+    :param handle_error: Called in the case of an error, taking an exception argument.
+    :type handle_error: collections.abc.Callable | None
+    """
+
+def disable_all(): ...
+def enable(
+    module_name: str,
+    *,
+    default_set: bool = False,
+    persistent: bool = False,
+    refresh_handled: bool = False,
+    handle_error: collections.abc.Callable | None = None,
+):
+    """Enables an addon by name.
+
+        :param module_name: the name of the addon and module.
+        :type module_name: str
+        :param default_set: Set the user-preference.
+        :type default_set: bool
+        :param persistent: Ensure the addon is enabled for the entire session (after loading new files).
+        :type persistent: bool
+        :param refresh_handled: When true, `extensions_refresh` must have been called with module_name
+    included in addon_modules_pending.
+    This should be used to avoid many calls to refresh extensions when enabling multiple add-ons at once.
+        :type refresh_handled: bool
+        :param handle_error: Called in the case of an error, taking an exception argument.
+        :type handle_error: collections.abc.Callable | None
+        :return: the loaded module or None on failure.
+    """
+
+def extensions_refresh(ensure_wheels: bool = True, addon_modules_pending=None):
+    """Ensure data relating to extensions is up to date.
+    This should be called after extensions on the file-system have changed.
+
+        :param ensure_wheels: When true, refresh installed wheels with wheels used by extensions.
+        :type ensure_wheels: bool
+        :param addon_modules_pending: Refresh these add-ons by listing their package names, as if they are enabled.
+    This is needed so wheels can be setup before the add-on is enabled.
+    """
+
+def module_bl_info(mod, *, info_basis=None): ...
+def modules(*, module_cache={}, refresh=True): ...
+def modules_refresh(*, module_cache={}): ...
+def paths(): ...
+def reset_all(*, reload_scripts=False):
+    """Sets the addon state based on the user preferences."""
+
+def stale_pending_remove_paths(path_base, paths): ...
+def stale_pending_stage_paths(path_base, paths): ...

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_console_utils/autocomplete/complete_calltip/__init__.pyi

@@ -2,7 +2,7 @@ import typing
 import collections.abc
 import typing_extensions
 
-def complete(line: str, cursor: int, namespace: dict) -> str:
+def complete(line: str, cursor: int, namespace) -> str:
     """Complete callable with call-tip.
 
     :param line: incomplete text line
@@ -10,7 +10,6 @@ def complete(line: str, cursor: int, namespace: dict) -> str:
     :param cursor: current character position
     :type cursor: int
     :param namespace: namespace
-    :type namespace: dict
     :return: (matches, world, scrollback)
     :rtype: str
     """

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_console_utils/autocomplete/complete_import/__init__.pyi

@@ -2,7 +2,7 @@ import typing
 import collections.abc
 import typing_extensions
 
-def complete(line: str) -> list:
+def complete(line: str):
     """Returns a list containing the completion possibilities for an import line.
 
         :param line: incomplete line which contains an import statement:
@@ -11,23 +11,20 @@ def complete(line: str) -> list:
     from xml.dom import
         :type line: str
         :return: list of completion possibilities
-        :rtype: list
     """
 
-def get_root_modules() -> list:
+def get_root_modules():
     """Returns a list containing the names of all the modules available in the
     folders of the python-path.
 
         :return: modules
-        :rtype: list
     """
 
-def module_list(path: str) -> list:
+def module_list(path: str):
     """Return the list containing the names of the modules available in
     the given folder.
 
         :param path: folder path
         :type path: str
         :return: modules
-        :rtype: list
     """

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_console_utils/autocomplete/complete_namespace/__init__.pyi

@@ -32,13 +32,12 @@ def complete_indices(
     :rtype: list[str]
     """
 
-def complete_names(word: str, namespace: dict) -> list[str]:
+def complete_names(word: str, namespace) -> list[str]:
     """Complete variable names or attributes
 
     :param word: word to be completed
     :type word: str
     :param namespace: namespace
-    :type namespace: dict
     :return: completion matches
     :rtype: list[str]
     """

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_console_utils/autocomplete/intellisense/__init__.pyi

@@ -2,7 +2,7 @@ import typing
 import collections.abc
 import typing_extensions
 
-def complete(line: str, cursor: int, namespace: dict, private: bool) -> list | str:
+def complete(line: str, cursor: int, namespace: dict, private: bool):
     """Returns a list of possible completions:
 
     :param line: incomplete text line
@@ -14,12 +14,9 @@ def complete(line: str, cursor: int, namespace: dict, private: bool) -> list | s
     :param private: whether private variables should be listed
     :type private: bool
     :return: list of completions, word
-    :rtype: list | str
     """
 
-def expand(
-    line: str, cursor: int, namespace: dict, *, private: bool = True
-) -> int | str:
+def expand(line: str, cursor: int, namespace, *, private: bool = True) -> int | str:
     """This method is invoked when the user asks auto-completion,
     e.g. when Ctrl+Space is clicked.
 
@@ -28,7 +25,6 @@ def expand(
         :param cursor: current character position
         :type cursor: int
         :param namespace: namespace
-        :type namespace: dict
         :param private: whether private variables should be listed
         :type private: bool
         :return: current expanded line, updated cursor position and scrollback

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_operators/image_as_planes/__init__.pyi

@@ -76,7 +76,7 @@ class IMAGE_OT_import_as_mesh_planes(
     t: typing.Any
 
     def align_plane(self, context, plane):
-        """Pick an axis and align the plane to it
+        """
 
         :param context:
         :param plane:
@@ -110,7 +110,7 @@ class IMAGE_OT_import_as_mesh_planes(
         """
 
     def compute_plane_size(self, context, img_spec):
-        """Given the image size in pixels and location, determine size of plane
+        """
 
         :param context:
         :param img_spec:
@@ -169,7 +169,7 @@ class IMAGE_OT_import_as_mesh_planes(
         """
 
     def update_size_mode(self, _context):
-        """If sizing relative to the camera, always face the camera
+        """
 
         :param _context:
         """
@@ -200,44 +200,17 @@ class TextureProperties_MixIn:
         """
 
 def apply_texture_options(self_, texture, img_spec): ...
-def auto_align_nodes(node_tree):
-    """Given a shader node tree, arrange nodes neatly relative to the output node."""
-
-def center_in_camera(camera, ob, axis=(1, 1)):
-    """Center object along specified axis of the camera"""
-
-def clean_node_tree(node_tree):
-    """Clear all nodes in a shader node tree except the output.Returns the output node"""
-
-def compute_camera_size(context, center, fill_mode, aspect):
-    """Determine how large an object needs to be to fit or fill the camera's field of view."""
-
+def auto_align_nodes(node_tree): ...
+def center_in_camera(camera, ob, axis=(1, 1)): ...
+def clean_node_tree(node_tree): ...
+def compute_camera_size(context, center, fill_mode, aspect): ...
 def create_cycles_material(self_, context, img_spec, name): ...
 def create_cycles_texnode(self_, node_tree, img_spec): ...
-def find_image_sequences(files):
-    """From a group of files, detect image sequences.This returns a generator of tuples, which contain the filename,
-    start frame, and length of the detected sequence
-
-    """
-
-def get_input_nodes(node, links):
-    """Get nodes that are a inputs to the given node"""
-
+def find_image_sequences(files): ...
+def get_input_nodes(node, links): ...
 def get_ref_object_space_coord(ob): ...
-def get_shadeless_node(dest_node_tree):
-    """Return a "shadeless" cycles/EEVEE node, creating a node group if nonexistent"""
-
+def get_shadeless_node(dest_node_tree): ...
 def load_images(
     filenames, directory, force_reload=False, frame_start=1, find_sequences=False
-):
-    """Wrapper for bpy_extras.image_utils.load_image.Loads a set of images, movies, or even image sequences
-    Returns a generator of ImageSpec wrapper objects later used for texture setup
-
-    """
-
-def offset_planes(planes, gap, axis):
-    """Offset planes from each other by gap amount along a _local_ vector axisFor example, offset_planes([obj1, obj2], 0.5, Vector(0, 0, 1)) will place
-    obj2 0.5 blender units away from obj1 along the local positive Z axis.This is in local space, not world space, so all planes should share
-    a common scale and rotation.
-
-    """
+): ...
+def offset_planes(planes, gap, axis): ...

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_operators/uvcalc_transform/__init__.pyi

@@ -1,7 +1,6 @@
 import typing
 import collections.abc
 import typing_extensions
-import bmesh.types
 import bpy.types
 
 class AlignUVRotation(bpy.types.Operator):
@@ -90,47 +89,10 @@ def find_rotation_edge(bm, uv_layer, faces, aspect_y): ...
 def find_rotation_geometry(bm, uv_layer, faces, method, axis, aspect_y): ...
 def get_aspect_y(context): ...
 def get_random_transform(transform_params, entropy): ...
-def is_face_uv_selected(face: bmesh.types.BMFace, uv_layer, any_edge: bool) -> bool:
-    """Returns True if the face is UV selected.
-
-    :param face: the face to query.
-    :type face: bmesh.types.BMFace
-    :param uv_layer: the UV layer to source UVs from.
-    :param any_edge: use edge selection instead of vertex selection.
-    :type any_edge: bool
-    :return: True if the face is UV selected.
-    :rtype: bool
-    """
-
-def is_island_uv_selected(island, uv_layer, any_edge: bool) -> bool:
-    """Returns True if the island is UV selected.
-
-    :param island: list of faces to query.
-    :param uv_layer: the UV layer to source UVs from.
-    :param any_edge: use edge selection instead of vertex selection.
-    :type any_edge: bool
-    :return: list of lists containing polygon indices.
-    :rtype: bool
-    """
-
-def island_uv_bounds(island, uv_layer) -> list:
-    """The UV bounds of UV island.
-
-    :param island: list of faces to query.
-    :param uv_layer: the UV layer to source UVs from.
-    :return: U-min, V-min, U-max, V-max.
-    :rtype: list
-    """
-
-def island_uv_bounds_center(island, uv_layer) -> tuple:
-    """The UV bounds center of UV island.
-
-    :param island: list of faces to query.
-    :param uv_layer: the UV layer to source UVs from.
-    :return: U, V center.
-    :rtype: tuple
-    """
-
+def is_face_uv_selected(face, uv_layer, any_edge): ...
+def is_island_uv_selected(island, uv_layer, any_edge): ...
+def island_uv_bounds(island, uv_layer): ...
+def island_uv_bounds_center(island, uv_layer): ...
 def randomize_uv_transform(context, transform_params): ...
 def randomize_uv_transform_bmesh(mesh, bm, transform_params): ...
 def randomize_uv_transform_island(bm, uv_layer, faces, transform_params): ...

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_operators/wm/__init__.pyi

@@ -1337,6 +1337,14 @@ class WM_OT_tool_set_by_id(bpy.types.Operator):
         :param context:
         """
 
+    @staticmethod
+    def space_type_from_operator(op, context):
+        """
+
+        :param op:
+        :param context:
+        """
+
 class WM_OT_tool_set_by_index(bpy.types.Operator):
     """Set the tool by index (for key-maps)"""
 

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_ui/generic_ui_list/__init__.pyi

@@ -128,7 +128,7 @@ def draw_ui_list(
     move_operators: str = True,
     menu_class_name: str = "",
     **kwargs,
-):
+) -> bpy.types.UILayout:
     """Draw a UIList with Add/Remove/Move buttons and a menu.Additional keyword arguments are passed to `UIList.template_list`.
 
         :param layout: UILayout to draw the list in.
@@ -151,4 +151,5 @@ def draw_ui_list(
         :param menu_class_name: Identifier of a Menu that should be drawn as a drop-down.
         :type menu_class_name: str
         :return: The right side column.
+        :rtype: bpy.types.UILayout
     """

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_ui/properties_grease_pencil_common/__init__.pyi

@@ -433,10 +433,3 @@ class GreasePencilSimplifyPanel:
 
         :param context:
         """
-
-class GreasePencilVertexcolorPanel:
-    def draw(self, context):
-        """
-
-        :param context:
-        """

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bl_ui/space_userpref/__init__.pyi

@@ -2398,10 +2398,10 @@ class USERPREF_PT_system_display_graphics(
         """
 
     @classmethod
-    def poll(cls, _context):
+    def poll(cls, context):
         """
 
-        :param _context:
+        :param context:
         """
 
 class USERPREF_PT_system_memory(CenterAlignMixIn, SystemPanel, bpy.types.Panel):

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/blf/__init__.pyi

@@ -5,7 +5,7 @@ This module provides access to Blender's text drawing functions.
 --------------------
 
 Example of using the blf module. For this module to work we
-need to use the OpenGL wrapper ~bgl as well.
+need to use the GPU module gpu as well.
 
 ```../examples/blf.py```
 
@@ -91,11 +91,10 @@ def enable(fontid: int, option: int):
     :type option: int
     """
 
-def load(filepath: bytes | str) -> int:
+def load(filepath) -> int:
     """Load a new font.
 
     :param filepath: the filepath of the font.
-    :type filepath: bytes | str
     :return: the new font's fontid or -1 if there was an error.
     :rtype: int
     """
@@ -159,11 +158,10 @@ def size(fontid: int, size: float):
     :type size: float
     """
 
-def unload(filepath: bytes | str):
+def unload(filepath):
     """Unload an existing font.
 
     :param filepath: the filepath of the font.
-    :type filepath: bytes | str
     """
 
 def word_wrap(fontid: int, wrap_width: int):

{fake_bpy_module-20241103 → fake_bpy_module-20241111}/bmesh/types/__init__.pyi

@@ -46,20 +46,18 @@ class BMDeformVert:
                 :return: (key, value) pairs for each deform weight of this vertex.
         """
 
-    def keys(self) -> list[int]:
+    def keys(self):
         """Return the group indices used by this vertex
         (matching Python's dict.keys() functionality).
 
                 :return: the deform group this vertex uses
-                :rtype: list[int]
         """
 
-    def values(self) -> list[float]:
+    def values(self):
         """Return the weights of the deform vertex
         (matching Python's dict.values() functionality).
 
                 :return: The weights that influence this vertex
-                :rtype: list[float]
         """
 
 class BMEdge:
@@ -155,22 +153,20 @@ class BMEdge:
     :type: BMElemSeq[BMVert]
     """
 
-    def calc_face_angle(self, fallback: typing.Any | None = None) -> float:
+    def calc_face_angle(self, fallback=None) -> float:
         """
 
                 :param fallback: return this when the edge doesn't have 2 faces
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The angle between 2 connected faces in radians.
                 :rtype: float
         """
 
-    def calc_face_angle_signed(self, fallback: typing.Any | None = None) -> float:
+    def calc_face_angle_signed(self, fallback=None) -> float:
         """
 
                 :param fallback: return this when the edge doesn't have 2 faces
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The angle between 2 connected faces in radians (negative for concave join).
                 :rtype: float
         """
@@ -210,13 +206,12 @@ class BMEdge:
     def normal_update(self):
         """Update normals of all connected faces and the edge verts."""
 
-    def other_vert(self, vert: BMVert) -> BMVert:
+    def other_vert(self, vert: BMVert):
         """Return the other vertex on this edge or None if the vertex is not used by this edge.
 
         :param vert: a vert in this edge.
         :type vert: BMVert
         :return: The edges other vert.
-        :rtype: BMVert
         """
 
     def select_set(self, select: bool):
@@ -266,11 +261,10 @@ class BMEdgeSeq:
     def ensure_lookup_table(self):
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
 
-    def get(self, verts: list[BMVert], fallback=None) -> BMEdge:
+    def get(self, verts, fallback=None) -> BMEdge:
         """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: list[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The edge found or None
         :rtype: BMEdge
@@ -279,13 +273,10 @@ class BMEdgeSeq:
     def index_update(self):
         """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
 
-    def new(
-        self, verts: tuple[BMVert, BMVert], example: BMEdge | None = None
-    ) -> BMEdge:
+    def new(self, verts, example: BMEdge | None = None) -> BMEdge:
         """Create a new edge from a given pair of verts.
 
         :param verts: Vertex pair.
-        :type verts: tuple[BMVert, BMVert]
         :param example: Existing edge to initialize settings (optional argument).
         :type example: BMEdge | None
         :return: The newly created edge.
@@ -299,11 +290,12 @@ class BMEdgeSeq:
         :type edge: BMEdge
         """
 
-    def sort(self, key=None, reverse: bool = False):
+    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
         """Sort the elements of this sequence, using an optional custom sort key.
         Indices of elements are not changed, `BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
+                :type key: collections.abc.Callable | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -647,11 +639,10 @@ class BMFaceSeq:
     def ensure_lookup_table(self):
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
 
-    def get(self, verts: list[BMVert], fallback=None) -> BMFace:
+    def get(self, verts, fallback=None) -> BMFace:
         """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: list[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The face found or None
         :rtype: BMFace
@@ -660,11 +651,10 @@ class BMFaceSeq:
     def index_update(self):
         """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
 
-    def new(self, verts: list[BMVert], example: BMFace | None = None) -> BMFace:
+    def new(self, verts, example: BMFace | None = None) -> BMFace:
         """Create a new face from a given set of verts.
 
         :param verts: Sequence of 3 or more verts.
-        :type verts: list[BMVert]
         :param example: Existing face to initialize settings (optional argument).
         :type example: BMFace | None
         :return: The newly created face.
@@ -678,11 +668,12 @@ class BMFaceSeq:
         :type face: BMFace
         """
 
-    def sort(self, key=None, reverse: bool = False):
+    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
         """Sort the elements of this sequence, using an optional custom sort key.
         Indices of elements are not changed, `BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
+                :type key: collections.abc.Callable | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -967,12 +958,11 @@ class BMLayerCollection[_GenericType1]:
                 :rtype: list[str, BMLayerItem[_GenericType1]]
         """
 
-    def keys(self) -> list[str]:
+    def keys(self):
         """Return the identifiers of collection members
         (matching Python's dict.keys() functionality).
 
                 :return: the identifiers for each member of this collection.
-                :rtype: list[str]
         """
 
     def new(self, name: str | None = "") -> BMLayerItem[_GenericType1]:
@@ -1317,12 +1307,11 @@ class BMVert:
     :type: bool
     """
 
-    def calc_edge_angle(self, fallback: typing.Any | None = None) -> float:
+    def calc_edge_angle(self, fallback=None) -> float:
         """Return the angle between this vert's two connected edges.
 
                 :param fallback: return this when the vert doesn't have 2 edges
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: Angle between edges in radians.
                 :rtype: float
         """
@@ -1350,11 +1339,10 @@ class BMVert:
         :type face: BMFace
         """
 
-    def copy_from_vert_interp(self, vert_pair: tuple[BMVert, BMVert], fac: float):
+    def copy_from_vert_interp(self, vert_pair, fac: float):
         """Interpolate the customdata from a vert between 2 other verts.
 
         :param vert_pair: The verts between which to interpolate data from.
-        :type vert_pair: tuple[BMVert, BMVert]
         :param fac:
         :type fac: float
         """
@@ -1445,11 +1433,12 @@ class BMVertSeq:
         :type vert: BMVert
         """
 
-    def sort(self, key=None, reverse: bool = False):
+    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
         """Sort the elements of this sequence, using an optional custom sort key.
         Indices of elements are not changed, `BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
+                :type key: collections.abc.Callable | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -1539,10 +1528,11 @@ class BMesh:
     :type: BMVertSeq
     """
 
-    def calc_loop_triangles(self):
+    def calc_loop_triangles(self) -> BMLoop:
         """Calculate triangle tessellation from quads/ngons.
 
         :return: The triangulated faces.
+        :rtype: BMLoop
         """
 
     def calc_volume(self, signed: bool = False) -> float:
@@ -1635,12 +1625,11 @@ class BMesh:
         self,
         matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
         | mathutils.Matrix,
-        filter: set | None = None,
+        filter=None,
     ):
         """Transform the mesh (optionally filtering flagged data only).
 
-        :param matrix: transform matrix.
+        :param matrix: 4x4x transform matrix.
         :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
         :param filter: set of values in ('SELECT', 'HIDE', 'SEAM', 'SMOOTH', 'TAG').
-        :type filter: set | None
         """