fake-bpy-module 20241206__py3-none-any.whl → 20241208__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -29,7 +29,7 @@ class BMDeformVert:
     def clear(self):
         """Clears all weights."""
 
-    def get(self, key: int, default=None):
+    def get(self, key: int, default: typing.Any | None = None):
         """Returns the deform weight matching the key or default
         when not found (matches Python's dictionary function of the same name).
 
@@ -37,27 +37,31 @@ class BMDeformVert:
                 :type key: int
                 :param default: Optional argument for the value to return if
         key is not found.
+                :type default: typing.Any | None
         """
 
-    def items(self):
+    def items(self) -> list[tuple[int, float]]:
         """Return (group, weight) pairs for this vertex
         (matching Python's dict.items() functionality).
 
                 :return: (key, value) pairs for each deform weight of this vertex.
+                :rtype: list[tuple[int, float]]
         """
 
-    def keys(self):
+    def keys(self) -> list[int]:
         """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):
+    def values(self) -> list[float]:
         """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:
@@ -153,20 +157,22 @@ class BMEdge:
     :type: BMElemSeq[BMVert]
     """
 
-    def calc_face_angle(self, fallback=None) -> float:
+    def calc_face_angle(self, fallback: typing.Any | None = 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=None) -> float:
+    def calc_face_angle_signed(self, fallback: typing.Any | None = 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
         """
@@ -959,11 +965,12 @@ class BMLayerCollection[_GenericType1]:
                 :rtype: list[str, BMLayerItem[_GenericType1]]
         """
 
-    def keys(self):
+    def keys(self) -> list[str]:
         """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]:
@@ -1308,11 +1315,12 @@ class BMVert:
     :type: bool
     """
 
-    def calc_edge_angle(self, fallback=None) -> float:
+    def calc_edge_angle(self, fallback: typing.Any | None = 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
         """
@@ -1529,11 +1537,11 @@ class BMesh:
     :type: BMVertSeq
     """
 
-    def calc_loop_triangles(self) -> BMLoop:
+    def calc_loop_triangles(self) -> list[tuple[BMLoop, BMLoop, BMLoop]]:
         """Calculate triangle tessellation from quads/ngons.
 
         :return: The triangulated faces.
-        :rtype: BMLoop
+        :rtype: list[tuple[BMLoop, BMLoop, BMLoop]]
         """
 
     def calc_volume(self, signed: bool = False) -> float:

bmesh/utils/__init__.pyi

@@ -20,7 +20,9 @@ def edge_rotate(edge: bmesh.types.BMEdge, ccw: bool = False) -> bmesh.types.BMEd
         :rtype: bmesh.types.BMEdge
     """
 
-def edge_split(edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float):
+def edge_split(
+    edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float
+) -> tuple[bmesh.types.BMEdge, bmesh.types.BMVert]:
     """Split an edge, return the newly created data.
 
     :param edge: The edge to split.
@@ -30,6 +32,7 @@ def edge_split(edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float):
     :param fac: The point on the edge where the new vert will be created [0 - 1].
     :type fac: float
     :return: The newly created (edge, vert) pair.
+    :rtype: tuple[bmesh.types.BMEdge, bmesh.types.BMVert]
     """
 
 def face_flip(faces):
@@ -53,7 +56,7 @@ def face_split(
     coords=(),
     use_exist: bool = True,
     example: bmesh.types.BMEdge | None = None,
-):
+) -> tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
     """Face split with optional intermediate points.
 
     :param face: The face to cut.
@@ -68,15 +71,19 @@ def face_split(
     :param example: Newly created edge will copy settings from this one.
     :type example: bmesh.types.BMEdge | None
     :return: The newly created face or None on failure.
+    :rtype: tuple[bmesh.types.BMFace, bmesh.types.BMLoop]
     """
 
-def face_split_edgenet(face: bmesh.types.BMFace, edgenet):
+def face_split_edgenet(
+    face: bmesh.types.BMFace, edgenet
+) -> tuple[bmesh.types.BMFace, int]:
     """Splits a face into any number of regions defined by an edgenet.
 
     :param face: The face to split.The face to split.
     :type face: bmesh.types.BMFace
     :param edgenet: Sequence of edges.
     :return: The newly created faces.
+    :rtype: tuple[bmesh.types.BMFace, int]
     """
 
 def face_vert_separate(
@@ -140,7 +147,9 @@ def vert_dissolve(vert: bmesh.types.BMVert) -> bool:
     :rtype: bool
     """
 
-def vert_separate(vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge):
+def vert_separate(
+    vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge
+) -> tuple[bmesh.types.BMVert, int]:
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
@@ -148,6 +157,7 @@ def vert_separate(vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge):
     :param edges: The edges to separated.
     :type edges: bmesh.types.BMEdge
     :return: The newly separated verts (including the vertex passed).
+    :rtype: tuple[bmesh.types.BMVert, int]
     """
 
 def vert_splice(vert: bmesh.types.BMVert, vert_target: bmesh.types.BMVert):

bpy/app/icons/__init__.pyi

@@ -2,10 +2,13 @@ import typing
 import collections.abc
 import typing_extensions
 
-def new_triangles(range, coords: bytes | None, colors: bytes | None) -> int:
+def new_triangles(
+    range: tuple[int, int] | None, coords: bytes | None, colors: bytes | None
+) -> int:
     """Create a new icon from triangle geometry.
 
     :param range: Pair of ints.
+    :type range: tuple[int, int] | None
     :param coords: Sequence of bytes (6 floats for one triangle) for (X, Y) coordinates.
     :type coords: bytes | None
     :param colors: Sequence of bytes (12 for one triangles) for RGBA.

bpy/app/translations/__init__.pyi

@@ -127,13 +127,16 @@ def pgettext_tip(msgid: str | None, msgctxt: str | None = None):
     :return: The translated string (or msgid if no translation was found).
     """
 
-def register(module_name: str | None, translations_dict):
+def register(
+    module_name: str | None, translations_dict: dict[str, dict[str, str]] | None
+):
     """Registers an addon's UI translations.
 
         :param module_name: The name identifying the addon.
         :type module_name: str | None
         :param translations_dict: A dictionary built like that:
     {locale: {msg_key: msg_translation, ...}, ...}
+        :type translations_dict: dict[str, dict[str, str]] | None
     """
 
 def unregister(module_name: str | None):

bpy/msgbus/__init__.pyi

@@ -52,7 +52,9 @@ import bpy.types
 def clear_by_owner(owner):
     """Clear all subscribers using this owner."""
 
-def publish_rna(key: bpy.types.Property | bpy.types.Struct | None):
+def publish_rna(
+    key: bpy.types.Property | bpy.types.Struct | tuple[bpy.types.Struct, str] | None,
+):
     """Notify subscribers of changes to this property
     (this typically doesn't need to be called explicitly since changes will automatically publish updates).
     In some cases it may be useful to publish changes explicitly using more general keys.
@@ -63,12 +65,12 @@ def publish_rna(key: bpy.types.Property | bpy.types.Struct | None):
     - A property instance.
     - A struct type.
     - A tuple representing a (struct, property name) pair.
-        :type key: bpy.types.Property | bpy.types.Struct | None
+        :type key: bpy.types.Property | bpy.types.Struct | tuple[bpy.types.Struct, str] | None
     """
 
 def subscribe_rna(
-    key: bpy.types.Property | bpy.types.Struct | None,
-    owner,
+    key: bpy.types.Property | bpy.types.Struct | tuple[bpy.types.Struct, str] | None,
+    owner: typing.Any | None,
     args,
     notify,
     options=set(),
@@ -82,8 +84,9 @@ def subscribe_rna(
     - A property instance.
     - A struct type.
     - A tuple representing a (struct, property name) pair.
-        :type key: bpy.types.Property | bpy.types.Struct | None
+        :type key: bpy.types.Property | bpy.types.Struct | tuple[bpy.types.Struct, str] | None
         :param owner: Handle for this subscription (compared by identity).
+        :type owner: typing.Any | None
         :param options: Change the behavior of the subscriber.
 
     PERSISTENT when set, the subscriber will be kept when remapping ID data.

bpy/path/__init__.pyi

@@ -104,7 +104,7 @@ def is_subdir(path: bytes | str, directory) -> bool:
         :rtype: bool
     """
 
-def module_names(path: str, *, recursive: bool = False, package: str = ""):
+def module_names(path: str, *, recursive: bool = False, package: str = "") -> list[str]:
     """Return a list of modules which can be imported from path.
 
     :param path: a directory to scan.
@@ -114,6 +114,7 @@ def module_names(path: str, *, recursive: bool = False, package: str = ""):
     :param package: Optional string, used as the prefix for module names (without the trailing ".").
     :type package: str
     :return: a list of string pairs (module_name, module_file).
+    :rtype: list[str]
     """
 
 def native_pathsep(path: str) -> str:
@@ -125,13 +126,14 @@ def native_pathsep(path: str) -> str:
     :rtype: str
     """
 
-def reduce_dirs(dirs):
+def reduce_dirs(dirs) -> list[str]:
     """Given a sequence of directories, remove duplicates and
     any directories nested in one of the other paths.
     (Useful for recursive path searching).
 
         :param dirs: Sequence of directory paths.
         :return: A unique list of paths.
+        :rtype: list[str]
     """
 
 def relpath(path: bytes | str, *, start: bytes | str | None = None) -> str: