fake-bge-module 20250104__py3-none-any.whl → 20250202__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,30 +37,34 @@ 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[_GenericType1]:
+class BMEdge:
     """The BMesh edge connecting 2 verts"""
 
     hide: bool
@@ -153,20 +157,22 @@ class BMEdge[_GenericType1]:
     :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
         """
@@ -206,12 +212,13 @@ class BMEdge[_GenericType1]:
     def normal_update(self):
         """Update normals of all connected faces and the edge verts."""
 
-    def other_vert(self, vert: BMVert):
+    def other_vert(self, vert: BMVert) -> BMVert | None:
         """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 | None
         """
 
     def select_set(self, select: bool):
@@ -222,7 +229,9 @@ class BMEdge[_GenericType1]:
                 :type select: bool
         """
 
-    def __getitem__(self, key: BMLayerItem[_GenericType1]) -> _GenericType1:
+    def __getitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1]
+    ) -> _GenericType1:
         """
 
         :param key:
@@ -231,7 +240,9 @@ class BMEdge[_GenericType1]:
         :rtype: _GenericType1
         """
 
-    def __setitem__(self, key: BMLayerItem[_GenericType1], value: _GenericType1):
+    def __setitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1], value: _GenericType1
+    ):
         """
 
         :param key:
@@ -240,7 +251,7 @@ class BMEdge[_GenericType1]:
         :type value: _GenericType1
         """
 
-    def __delitem__(self, key: BMLayerItem[_GenericType1]):
+    def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]):
         """
 
         :param key:
@@ -257,10 +268,11 @@ 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, fallback=None) -> BMEdge:
+    def get(self, verts: collections.abc.Sequence[BMVert], fallback=None) -> BMEdge:
         """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
+        :type verts: collections.abc.Sequence[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The edge found or None
         :rtype: BMEdge
@@ -269,10 +281,13 @@ 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, example: BMEdge | None = None) -> BMEdge:
+    def new(
+        self, verts: collections.abc.Sequence[BMVert], example: BMEdge | None = None
+    ) -> BMEdge:
         """Create a new edge from a given pair of verts.
 
         :param verts: Vertex pair.
+        :type verts: collections.abc.Sequence[BMVert]
         :param example: Existing edge to initialize settings (optional argument).
         :type example: BMEdge | None
         :return: The newly created edge.
@@ -286,12 +301,18 @@ class BMEdgeSeq:
         :type edge: BMEdge
         """
 
-    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
+    def sort(
+        self,
+        key: None
+        | collections.abc.Callable[[BMVert | BMEdge | BMFace], int]
+        | 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
+                :type key: None | collections.abc.Callable[[BMVert | BMEdge | BMFace], int] | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -307,13 +328,13 @@ class BMEdgeSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> tuple[BMEdge, ...]:
+    def __getitem__(self, key: slice) -> list[BMEdge, ...]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: tuple[BMEdge, ...]
+        :rtype: list[BMEdge, ...]
         """
 
     def __iter__(self) -> BMIter[BMEdge]:
@@ -383,13 +404,13 @@ class BMElemSeq[_GenericType1]:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> tuple[_GenericType1, ...]:
+    def __getitem__(self, key: slice) -> list[_GenericType1, ...]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: tuple[_GenericType1, ...]
+        :rtype: list[_GenericType1, ...]
         """
 
     def __iter__(self) -> BMIter[_GenericType1]:
@@ -406,7 +427,7 @@ class BMElemSeq[_GenericType1]:
         :rtype: int
         """
 
-class BMFace[_GenericType1]:
+class BMFace:
     """The BMesh face with 3 or more sides"""
 
     edges: BMElemSeq[BMEdge]
@@ -590,7 +611,9 @@ class BMFace[_GenericType1]:
                 :type select: bool
         """
 
-    def __getitem__(self, key: BMLayerItem[_GenericType1]) -> _GenericType1:
+    def __getitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1]
+    ) -> _GenericType1:
         """
 
         :param key:
@@ -599,7 +622,9 @@ class BMFace[_GenericType1]:
         :rtype: _GenericType1
         """
 
-    def __setitem__(self, key: BMLayerItem[_GenericType1], value: _GenericType1):
+    def __setitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1], value: _GenericType1
+    ):
         """
 
         :param key:
@@ -608,7 +633,7 @@ class BMFace[_GenericType1]:
         :type value: _GenericType1
         """
 
-    def __delitem__(self, key: BMLayerItem[_GenericType1]):
+    def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]):
         """
 
         :param key:
@@ -631,10 +656,11 @@ 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, fallback=None) -> BMFace:
+    def get(self, verts: collections.abc.Sequence[BMVert], fallback=None) -> BMFace:
         """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
+        :type verts: collections.abc.Sequence[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The face found or None
         :rtype: BMFace
@@ -643,10 +669,13 @@ 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, example: BMFace | None = None) -> BMFace:
+    def new(
+        self, verts: collections.abc.Sequence[BMVert], 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: collections.abc.Sequence[BMVert]
         :param example: Existing face to initialize settings (optional argument).
         :type example: BMFace | None
         :return: The newly created face.
@@ -660,12 +689,18 @@ class BMFaceSeq:
         :type face: BMFace
         """
 
-    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
+    def sort(
+        self,
+        key: None
+        | collections.abc.Callable[[BMVert | BMEdge | BMFace], int]
+        | 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
+                :type key: None | collections.abc.Callable[[BMVert | BMEdge | BMFace], int] | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -681,13 +716,13 @@ class BMFaceSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> tuple[BMFace, ...]:
+    def __getitem__(self, key: slice) -> list[BMFace, ...]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: tuple[BMFace, ...]
+        :rtype: list[BMFace, ...]
         """
 
     def __iter__(self) -> BMIter[BMFace]:
@@ -950,11 +985,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]:
@@ -1004,7 +1040,7 @@ class BMLayerItem[_GenericType1]:
         :type other: typing_extensions.Self
         """
 
-class BMLoop[_GenericType1]:
+class BMLoop:
     """This is normally accessed from `BMFace.loops` where each face loop represents a corner of the face."""
 
     edge: BMEdge
@@ -1123,7 +1159,9 @@ class BMLoop[_GenericType1]:
         :type multires: bool
         """
 
-    def __getitem__(self, key: BMLayerItem[_GenericType1]) -> _GenericType1:
+    def __getitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1]
+    ) -> _GenericType1:
         """
 
         :param key:
@@ -1132,7 +1170,9 @@ class BMLoop[_GenericType1]:
         :rtype: _GenericType1
         """
 
-    def __setitem__(self, key: BMLayerItem[_GenericType1], value: _GenericType1):
+    def __setitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1], value: _GenericType1
+    ):
         """
 
         :param key:
@@ -1141,7 +1181,7 @@ class BMLoop[_GenericType1]:
         :type value: _GenericType1
         """
 
-    def __delitem__(self, key: BMLayerItem[_GenericType1]):
+    def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]):
         """
 
         :param key:
@@ -1155,6 +1195,40 @@ class BMLoopSeq:
     :type: BMLayerAccessLoop
     """
 
+    @typing.overload
+    def __getitem__(self, key: int) -> BMLoop:
+        """
+
+        :param key:
+        :type key: int
+        :return:
+        :rtype: BMLoop
+        """
+
+    @typing.overload
+    def __getitem__(self, key: slice) -> list[BMLoop, ...]:
+        """
+
+        :param key:
+        :type key: slice
+        :return:
+        :rtype: list[BMLoop, ...]
+        """
+
+    def __iter__(self) -> BMIter[BMLoop]:
+        """
+
+        :return:
+        :rtype: BMIter[BMLoop]
+        """
+
+    def __len__(self) -> int:
+        """
+
+        :return:
+        :rtype: int
+        """
+
 class BMLoopUV:
     pin_uv: bool
     """ UV pin state.
@@ -1180,7 +1254,7 @@ class BMLoopUV:
     :type: mathutils.Vector
     """
 
-class BMVert[_GenericType1]:
+class BMVert:
     """The BMesh vertex type"""
 
     co: mathutils.Vector
@@ -1261,11 +1335,12 @@ class BMVert[_GenericType1]:
     :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
         """
@@ -1293,10 +1368,13 @@ class BMVert[_GenericType1]:
         :type face: BMFace
         """
 
-    def copy_from_vert_interp(self, vert_pair, fac: float):
+    def copy_from_vert_interp(
+        self, vert_pair: collections.abc.Sequence[BMVert], 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: collections.abc.Sequence[BMVert]
         :param fac:
         :type fac: float
         """
@@ -1323,7 +1401,9 @@ class BMVert[_GenericType1]:
                 :type select: bool
         """
 
-    def __getitem__(self, key: BMLayerItem[_GenericType1]) -> _GenericType1:
+    def __getitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1]
+    ) -> _GenericType1:
         """
 
         :param key:
@@ -1332,7 +1412,9 @@ class BMVert[_GenericType1]:
         :rtype: _GenericType1
         """
 
-    def __setitem__(self, key: BMLayerItem[_GenericType1], value: _GenericType1):
+    def __setitem__[_GenericType1](
+        self, key: BMLayerItem[_GenericType1], value: _GenericType1
+    ):
         """
 
         :param key:
@@ -1341,7 +1423,7 @@ class BMVert[_GenericType1]:
         :type value: _GenericType1
         """
 
-    def __delitem__(self, key: BMLayerItem[_GenericType1]):
+    def __delitem__[_GenericType1](self, key: BMLayerItem[_GenericType1]):
         """
 
         :param key:
@@ -1383,12 +1465,18 @@ class BMVertSeq:
         :type vert: BMVert
         """
 
-    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
+    def sort(
+        self,
+        key: None
+        | collections.abc.Callable[[BMVert | BMEdge | BMFace], int]
+        | 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
+                :type key: None | collections.abc.Callable[[BMVert | BMEdge | BMFace], int] | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -1404,13 +1492,13 @@ class BMVertSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> tuple[BMVert, ...]:
+    def __getitem__(self, key: slice) -> list[BMVert, ...]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: tuple[BMVert, ...]
+        :rtype: list[BMVert, ...]
         """
 
     def __iter__(self) -> BMIter[BMVert]:
@@ -1478,11 +1566,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):
@@ -50,10 +53,10 @@ def face_split(
     face: bmesh.types.BMFace,
     vert_a: bmesh.types.BMVert,
     vert_b: bmesh.types.BMVert,
-    coords=(),
+    coords: collections.abc.Sequence[collections.abc.Sequence[float]] = (),
     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.
@@ -63,20 +66,26 @@ def face_split(
     :param vert_b: Second vertex to cut in the face (face must contain the vert).
     :type vert_b: bmesh.types.BMVert
     :param coords: Optional sequence of 3D points in between vert_a and vert_b.
+    :type coords: collections.abc.Sequence[collections.abc.Sequence[float]]
     :param use_exist: .Use an existing edge if it exists (Only used when coords argument is empty or omitted)
     :type use_exist: bool
     :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: collections.abc.Sequence[bmesh.types.BMEdge]
+) -> tuple[bmesh.types.BMFace, ...]:
     """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.
+    :type edgenet: collections.abc.Sequence[bmesh.types.BMEdge]
     :return: The newly created faces.
+    :rtype: tuple[bmesh.types.BMFace, ...]
     """
 
 def face_vert_separate(
@@ -140,7 +149,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, ...]:
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
@@ -148,6 +159,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, ...]
     """
 
 def vert_splice(vert: bmesh.types.BMVert, vert_target: bmesh.types.BMVert):

bpy/__init__.pyi

@@ -16,10 +16,9 @@ from . import ops as ops
 from . import path as path
 from . import props as props
 from . import types as types
-from . import typing as typing
 from . import utils as utils
 
-context: bpy.types.Context | None
+context: bpy.types.Context
 
 data: bpy.types.BlendData
 """ Access to Blender's internal data

bpy/_typing/__init__.pyi

@@ -0,0 +1,4 @@
+import typing
+import collections.abc
+import typing_extensions
+from . import rna_enums as rna_enums