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

addon_utils/__init__.pyi

@@ -21,7 +21,8 @@ def disable(
     module_name: str,
     *,
     default_set: bool = False,
-    handle_error: typing.Any | None = None,
+    refresh_handled=False,
+    handle_error: collections.abc.Callable | None = None,
 ):
     """Disables an addon by name.
 
@@ -30,7 +31,7 @@ def disable(
     :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: typing.Any | None
+    :type handle_error: collections.abc.Callable | None
     """
 
 def disable_all(): ...
@@ -39,22 +40,36 @@ def enable(
     *,
     default_set: bool = False,
     persistent: bool = False,
-    handle_error: typing.Any | None = None,
+    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 handle_error: Called in the case of an error, taking an exception argument.
-    :type handle_error: typing.Any | None
-    :return: the loaded module or None on failure.
+        :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 extensions_refresh(ensure_wheels=True, addon_modules_pending=None): ...
 def module_bl_info(mod, *, info_basis=None): ...
 def modules(*, module_cache={}, refresh=True): ...
 def modules_refresh(*, module_cache={}): ...

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

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

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]
     """

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

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): ...

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): ...

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)"""
 

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

bl_ui/properties_grease_pencil_common/__init__.pyi

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

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):

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):