fake-bge-module 20250317__py3-none-any.whl → 20260201__py3-none-any.whl

bpy_extras/anim_utils/__init__.pyi

@@ -1,8 +1,12 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bpy.types
 
+class AutoKeying:
+    """Auto-keying support.Retrieve the lock status for 4D rotation."""
+
 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)"""
 
@@ -14,14 +18,14 @@ class KeyframesCo:
 
     keyframes_from_fcurve: typing.Any
 
-    def add_paths(self, rna_path, total_indices):
+    def add_paths(self, rna_path, total_indices) -> None:
         """
 
         :param rna_path:
         :param total_indices:
         """
 
-    def extend_co_value(self, rna_path, frame, value):
+    def extend_co_value(self, rna_path, frame, value) -> None:
         """
 
         :param rna_path:
@@ -29,7 +33,7 @@ class KeyframesCo:
         :param value:
         """
 
-    def extend_co_values(self, rna_path, total_indices, frame, values):
+    def extend_co_values(self, rna_path, total_indices, frame, values) -> None:
         """
 
         :param rna_path:
@@ -39,52 +43,61 @@ class KeyframesCo:
         """
 
     def insert_keyframes_into_existing_action(
-        self, lookup_fcurves, total_new_keys, action, action_slot
-    ):
+        self, lookup_fcurves, total_new_keys, channelbag
+    ) -> None:
         """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.
+        Its a substitute for channelbag.fcurves.find() which is a potentially expensive linear search.
                 :param total_new_keys:
-                :param action:
-                :param action_slot:
+                :param channelbag:
         """
 
     def insert_keyframes_into_new_action(
-        self, total_new_keys, action, action_group_name: str
-    ):
+        self, total_new_keys, channelbag, group_name
+    ) -> None:
         """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: Name of Action Group that F-curves are added to.
-                :type action_group_name: str
+                :param channelbag:
+                :param group_name: Name of the Group that F-curves are added to.
         """
 
-def action_get_channelbag_for_slot(action, slot):
+def action_ensure_channelbag_for_slot(action, slot) -> None:
+    """Ensure a layer and a keyframe strip exists, then ensure that strip has a channelbag for the slot."""
+
+def action_get_channelbag_for_slot(action, slot) -> None:
     """Returns the first channelbag found for the slot.
     In case there are multiple layers or strips they are iterated until a
     channelbag for that slot is found. In case no matching channelbag is found, returns None.
 
     """
 
+def action_get_first_suitable_slot(action, target_id_type) -> None:
+    """Return the first Slot of the given Action thats suitable for the given ID type.Typically you should not need this function; when an Action is assigned to a
+    data-block, just use the slot that was assigned along with it.
+
+    """
+
+def animdata_get_channelbag_for_assigned_slot(anim_data) -> None:
+    """Return the channelbag used in the given anim_data or None if there is no Action
+    + Slot combination defined.
+
+    """
+
 def bake_action(
     obj: bpy.types.Object, *, action: None | bpy.types.Action, frames: int, bake_options
 ) -> None | 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: None | bpy.types.Action
         :param frames: Frames to bake.
-        :type frames: int
         :param bake_options: Options for baking.
         :return: Action or None.
-        :rtype: None | bpy.types.Action
     """
 
 def bake_action_iter(
@@ -93,13 +106,10 @@ def bake_action_iter(
     """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: None | bpy.types.Action
         :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(
@@ -110,10 +120,9 @@ def bake_action_objects(
     :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: collections.abc.Sequence[bpy.types.Action]
     """
 
-def bake_action_objects_iter(object_action_pairs, bake_options):
+def bake_action_objects_iter(object_action_pairs, bake_options) -> None:
     """An coroutine that bakes actions for multiple objects.
 
         :param object_action_pairs: Sequence of object action tuples,

bpy_extras/asset_utils/__init__.pyi

@@ -6,6 +6,7 @@ Helpers for asset management tasks.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class AssetBrowserPanel: ...
 class AssetMetaDataPanel: ...

bpy_extras/bmesh_utils/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 def bmesh_linked_uv_islands(bm, uv_layer) -> list[list[int]]:
     """Returns lists of faces connected by UV islands.For meshes use `bpy.types.Mesh.mesh_linked_uv_islands` instead.
@@ -8,7 +9,6 @@ def bmesh_linked_uv_islands(bm, uv_layer) -> list[list[int]]:
     :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[list[int]]
     """
 
-def match_uv(face, vert, uv, uv_layer): ...
+def match_uv(face, vert, uv, uv_layer) -> None: ...

bpy_extras/id_map_utils/__init__.pyi

@@ -1,12 +1,21 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
+import bpy.types
 
-def get_all_referenced_ids(id, ref_map):
-    """Return a set of IDs directly or indirectly referenced by id."""
+def get_all_referenced_ids(
+    id: bpy.types.ID, ref_map: dict[bpy.types.ID, set[bpy.types.ID]]
+) -> set[bpy.types.ID]:
+    """Return a set of IDs directly or indirectly referenced by id.
 
-def get_id_reference_map():
-    """Return a dictionary of direct datablock references for every datablock in the blend file."""
+    :param id: Datablock whose references were interested in.
+    :param ref_map: The global ID reference map, retrieved from get_id_reference_map()
+    :return: Set of datablocks referenced by id.
+    """
 
-def recursive_get_referenced_ids(ref_map, id, referenced_ids, visited):
-    """Recursively populate referenced_ids with IDs referenced by id."""
+def get_id_reference_map() -> dict[bpy.types.ID, set[bpy.types.ID]]:
+    """Return a dictionary of direct data-block references for every data-block in the blend file.
+
+    :return: Each datablock of the .blend file mapped to the set of IDs they directly reference.
+    """

bpy_extras/image_utils/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bpy.types
 
 def load_image(
@@ -20,32 +21,23 @@ def load_image(
 
         :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.
+    convert it to a PNG and return the PNGs path.
     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: None | str | None
         :param check_existing: If true,
-    returns already loaded image datablock if possible
+    returns already loaded image data-block 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: None | bpy.types.Image
     """

bpy_extras/io_utils/__init__.pyi

@@ -1,17 +1,18 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bpy.types
 import mathutils
 
 class ExportHelper:
-    def check(self, _context):
+    def check(self, _context) -> None:
         """
 
         :param _context:
         """
 
-    def invoke(self, context, _event):
+    def invoke(self, context, _event) -> None:
         """
 
         :param context:
@@ -19,29 +20,30 @@ class ExportHelper:
         """
 
 class ImportHelper:
-    def check(self, _context):
+    def check(self, _context) -> None:
         """
 
         :param _context:
         """
 
-    def invoke(self, context, _event):
+    def invoke(self, context, _event) -> None:
         """
 
         :param context:
         :param _event:
         """
 
-    def invoke_popup(self, context, confirm_text=""):
+    def invoke_popup(self, context, confirm_text="") -> None:
         """
 
         :param context:
         :param confirm_text:
         """
 
-def axis_conversion(from_forward="Y", from_up="Z", to_forward="Y", to_up="Z"):
-    """Each argument us an axis in ['X', 'Y', 'Z', '-X', '-Y', '-Z']
+def axis_conversion(from_forward="Y", from_up="Z", to_forward="Y", to_up="Z") -> None:
+    """Each argument is an axis in [X, Y, Z, -X, -Y, -Z]
     where the first 2 are a source and the second 2 are the target.
+    :rtype: `mathutils.Matrix`
 
     """
 
@@ -52,13 +54,9 @@ def axis_conversion_ensure(
     to be used from `bpy.types.Operator.check`.
 
         :param operator: the operator to access axis attributes from.
-        :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
         :return: True if the value was modified.
-        :rtype: bool
     """
 
 def create_derived_objects(
@@ -67,15 +65,12 @@ def create_derived_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: collections.abc.Sequence[bpy.types.Object]
         :return: A dictionary where each key is an object from objects,
     values are lists of (object, matrix) tuples representing instances.
-        :rtype: dict[bpy.types.Object, list[tuple[bpy.types.Object, mathutils.Matrix]]]
     """
 
-def orientation_helper(axis_forward="Y", axis_up="Z"):
+def orientation_helper(axis_forward="Y", axis_up="Z") -> None:
     """A decorator for import/export classes, generating properties needed by the axis conversion system and IO helpers,
     with specified default values (axes).
 
@@ -87,43 +82,37 @@ def path_reference(
     base_dst: str,
     mode: str = "AUTO",
     copy_subdir: str = "",
-    copy_set=None,
+    copy_set: set[tuple[str, str]] | None = None,
     library: None | bpy.types.Library | None = None,
 ) -> str:
     """Return a filepath relative to a destination directory, for use with
     exporters.
 
         :param filepath: the file path to return,
-    supporting blenders relative '//' prefix.
-        :type filepath: str
+    supporting blenders relative // prefix.
         :param base_src: the directory the filepath is relative too
     (normally the blend file).
-        :type base_src: str
         :param base_dst: the directory the filepath will be referenced from
     (normally the export path).
-        :type base_dst: str
         :param mode: the method used get the path in
-    ['AUTO', 'ABSOLUTE', 'RELATIVE', 'MATCH', 'STRIP', 'COPY']
-        :type mode: str
-        :param copy_subdir: the subdirectory of base_dst to use when mode='COPY'.
-        :type copy_subdir: str
-        :param copy_set: collect from/to pairs when mode='COPY',
+    [AUTO, ABSOLUTE, RELATIVE, MATCH, STRIP, COPY]
+        :param copy_subdir: the subdirectory of base_dst to use when mode=COPY.
+        :param copy_set: collect from/to pairs when mode=COPY,
     pass to path_reference_copy when exporting is done.
         :param library: The library this path is relative to.
-        :type library: None | bpy.types.Library | None
         :return: the new filepath.
-        :rtype: str
     """
 
-def path_reference_copy(copy_set, report: collections.abc.Callable[str, None] = print):
+def path_reference_copy(
+    copy_set: set[tuple[str, str]], report: collections.abc.Callable[str, None] = print
+) -> None:
     """Execute copying files of path_reference
 
     :param copy_set: set of (from, to) pairs to copy.
     :param report: function used for reporting warnings, takes a string argument.
-    :type report: collections.abc.Callable[str, None]
     """
 
-def poll_file_object_drop(context):
+def poll_file_object_drop(context) -> None:
     """A default implementation for FileHandler poll_drop methods. Allows for both the 3D Viewport and
     the Outliner (in ViewLayer display mode) to be targets for file drag and drop.
 
@@ -136,7 +125,7 @@ def unique_name(
     name_max=-1,
     clean_func: typing.Any | None = None,
     sep: str = ".",
-):
+) -> None:
     """Helper function for storing unique names which may have special characters
     stripped and restricted to a maximum length.
 
@@ -144,19 +133,14 @@ def unique_name(
     when available.
     This can be the object, mesh, material, etc instance itself.
     Any hashable object associated with the name.
-        :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: dict
         :param clean_func: Function to call on name before creating a unique value.
-        :type clean_func: typing.Any | None
         :param sep: Separator to use when between the name and a number when a
     duplicate name is found.
-        :type sep: str
     """
 
-def unpack_face_list(list_of_tuples): ...
-def unpack_list(list_of_tuples): ...
+def unpack_face_list(list_of_tuples) -> None: ...
+def unpack_list(list_of_tuples) -> None: ...

bpy_extras/keyconfig_utils/__init__.pyi

@@ -1,11 +1,12 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
-def addon_keymap_register(keymap_data):
-    """Register a set of keymaps for addons using a list of keymaps.See 'blender_defaults.py' for examples of the format this takes."""
+def addon_keymap_register(keymap_data) -> None:
+    """Register a set of keymaps for addons using a list of keymaps.See blender_default.py for examples of the format this takes."""
 
-def addon_keymap_unregister(keymap_data):
+def addon_keymap_unregister(keymap_data) -> None:
     """Unregister a set of keymaps for addons."""
 
-def keyconfig_test(kc): ...
+def keyconfig_test(kc) -> None: ...

bpy_extras/mesh_utils/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bpy.types
 import mathutils
 
@@ -8,17 +9,15 @@ def edge_face_count(mesh) -> list[int]:
     """
 
     :return: list face users for each item in mesh.edges.
-    :rtype: list[int]
     """
 
 def edge_face_count_dict(mesh) -> dict[tuple[int, int], int]:
     """
 
     :return: Dictionary of edge keys with their value set to the number of faces using each edge.
-    :rtype: dict[tuple[int, int], int]
     """
 
-def edge_loops_from_edges(mesh, edges=None):
+def edge_loops_from_edges(mesh, edges=None) -> None:
     """Edge loops defined by edgesTakes me.edges or a list of edges and returns the edge loopsreturn a list of vertex indices.
     [ [1, 6, 7, 2], ...]closed loops have matching start and end values.
 
@@ -31,18 +30,14 @@ def mesh_linked_triangles(
     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[list[bpy.types.MeshLoopTriangle]]
     """
 
 def mesh_linked_uv_islands(mesh: bpy.types.Mesh) -> list[list[int]]:
     """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[list[int]]
     """
 
 def ngon_tessellate(
@@ -52,21 +47,18 @@ def ngon_tessellate(
     indices: list[int],
     fix_loops: bool = True,
     debug_print=True,
-):
+) -> None:
     """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 3D vectors.
-        :type from_data: bpy.types.Mesh | list[collections.abc.Sequence[float]] | tuple[collections.abc.Sequence[float]]
         :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[int]
         :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(
@@ -76,9 +68,6 @@ def triangle_random_points(
     """Generates a list of random points over mesh loop triangles.
 
     :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.
-    :type loop_triangles: collections.abc.Sequence[bpy.types.MeshLoopTriangle]
     :return: List of random points over all triangles.
-    :rtype: list[mathutils.Vector]
     """