fake-bpy-module 20240528__py3-none-any.whl → 20240530__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -203,10 +203,11 @@ class BMEdge:
         """
         ...
 
-    def copy_from(self, other):
+    def copy_from(self, other: BMEdge):
         """Copy values from another element of matching type.
 
         :param other:
+        :type other: BMEdge
         """
         ...
 
@@ -242,6 +243,34 @@ class BMEdge:
         """
         ...
 
+    def __getitem__(self, key: BMLayerItem) -> typing.Any:
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        :return:
+        :rtype: typing.Any
+        """
+        ...
+
+    def __setitem__(self, key: BMLayerItem, value: typing.Any):
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        :param value:
+        :type value: typing.Any
+        """
+        ...
+
+    def __delitem__(self, key: BMLayerItem):
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        """
+        ...
+
 class BMEdgeSeq:
     layers: BMLayerAccessEdge
     """ custom-data layers (read-only).
@@ -253,11 +282,11 @@ class BMEdgeSeq:
         """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: BMVert, fallback=None) -> BMEdge:
+    def get(self, verts: collections.abc.Iterable[BMVert], fallback=None) -> BMEdge:
         """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: BMVert
+        :type verts: collections.abc.Iterable[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The edge found or None
         :rtype: BMEdge
@@ -268,21 +297,22 @@ class BMEdgeSeq:
         """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) -> BMEdge:
+    def new(self, verts, example: BMEdge | None = None) -> BMEdge:
         """Create a new edge from a given pair of verts.
 
         :param verts: Vertex pair.
         :param example: Existing edge to initialize settings (optional argument).
-        :type example: BMEdge
+        :type example: BMEdge | None
         :return: The newly created edge.
         :rtype: BMEdge
         """
         ...
 
-    def remove(self, edge):
+    def remove(self, edge: BMEdge):
         """Remove an edge.
 
         :param edge:
+        :type edge: BMEdge
         """
         ...
 
@@ -306,39 +336,11 @@ class BMEdgeSeq:
         """
         ...
 
-    def __setitem__(self, key: int, value: BMEdge):
-        """
-
-        :param key:
-        :type key: int
-        :param value:
-        :type value: BMEdge
-        """
-        ...
-
-    def __delitem__(self, key: int) -> BMEdge:
-        """
-
-        :param key:
-        :type key: int
-        :return:
-        :rtype: BMEdge
-        """
-        ...
-
-    def __iter__(self) -> typing.Iterator[GenericType1]:
-        """
-
-        :return:
-        :rtype: typing.Iterator[GenericType1]
-        """
-        ...
-
-    def __next__(self) -> GenericType1:
+    def __iter__(self) -> BMIter[BMEdge]:
         """
 
         :return:
-        :rtype: GenericType1
+        :rtype: BMIter[BMEdge]
         """
         ...
 
@@ -388,7 +390,7 @@ class BMEditSelSeq:
         """Ensures all elements in the selection history are selected."""
         ...
 
-class BMElemSeq:
+class BMElemSeq(typing.Generic[GenericType1]):
     """General sequence type used for accessing any sequence of
     `BMVert`, `BMEdge`, `BMFace`, `BMLoop`.When accessed via `BMesh.verts`, `BMesh.edges`, `BMesh.faces`
     there are also functions to create/remove items.
@@ -408,39 +410,11 @@ class BMElemSeq:
         """
         ...
 
-    def __setitem__(self, key: int, value: GenericType1):
-        """
-
-        :param key:
-        :type key: int
-        :param value:
-        :type value: GenericType1
-        """
-        ...
-
-    def __delitem__(self, key: int) -> GenericType1:
-        """
-
-        :param key:
-        :type key: int
-        :return:
-        :rtype: GenericType1
-        """
-        ...
-
-    def __iter__(self) -> typing.Iterator[GenericType1]:
-        """
-
-        :return:
-        :rtype: typing.Iterator[GenericType1]
-        """
-        ...
-
-    def __next__(self) -> GenericType1:
+    def __iter__(self) -> BMIter[GenericType1]:
         """
 
         :return:
-        :rtype: GenericType1
+        :rtype: BMIter[GenericType1]
         """
         ...
 
@@ -491,10 +465,10 @@ class BMFace:
     :type: int
     """
 
-    normal: typing.Sequence[float] | mathutils.Vector
+    normal: collections.abc.Sequence[float] | mathutils.Vector
     """ The normal for this face as a 3D, wrapped vector.
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
     select: bool
@@ -605,10 +579,11 @@ class BMFace:
         """
         ...
 
-    def copy_from(self, other):
+    def copy_from(self, other: BMFace):
         """Copy values from another element of matching type.
 
         :param other:
+        :type other: BMFace
         """
         ...
 
@@ -651,6 +626,34 @@ class BMFace:
         """
         ...
 
+    def __getitem__(self, key: BMLayerItem) -> typing.Any:
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        :return:
+        :rtype: typing.Any
+        """
+        ...
+
+    def __setitem__(self, key: BMLayerItem, value: typing.Any):
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        :param value:
+        :type value: typing.Any
+        """
+        ...
+
+    def __delitem__(self, key: BMLayerItem):
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        """
+        ...
+
 class BMFaceSeq:
     active: BMFace
     """ active face.
@@ -668,11 +671,11 @@ class BMFaceSeq:
         """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: BMVert, fallback=None) -> BMFace:
+    def get(self, verts: collections.abc.Iterable[BMVert], fallback=None) -> BMFace:
         """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: BMVert
+        :type verts: collections.abc.Iterable[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The face found or None
         :rtype: BMFace
@@ -683,22 +686,25 @@ class BMFaceSeq:
         """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: typing.Iterable[BMVert], example: BMFace = None) -> BMFace:
+    def new(
+        self, verts: collections.abc.Iterable[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: typing.Iterable[BMVert]
+        :type verts: collections.abc.Iterable[BMVert]
         :param example: Existing face to initialize settings (optional argument).
-        :type example: BMFace
+        :type example: BMFace | None
         :return: The newly created face.
         :rtype: BMFace
         """
         ...
 
-    def remove(self, face):
+    def remove(self, face: BMFace):
         """Remove a face.
 
         :param face:
+        :type face: BMFace
         """
         ...
 
@@ -722,31 +728,32 @@ class BMFaceSeq:
         """
         ...
 
-    def __setitem__(self, key: int, value: BMFace):
+    def __iter__(self) -> BMIter[BMFace]:
         """
 
-        :param key:
-        :type key: int
-        :param value:
-        :type value: BMFace
+        :return:
+        :rtype: BMIter[BMFace]
         """
         ...
 
-    def __delitem__(self, key: int) -> BMFace:
+    def __len__(self) -> int:
         """
 
-        :param key:
-        :type key: int
         :return:
-        :rtype: BMFace
+        :rtype: int
         """
         ...
 
-    def __iter__(self) -> typing.Iterator[GenericType1]:
+class BMIter(typing.Generic[GenericType1]):
+    """Internal BMesh type for looping over verts/faces/edges,
+    used for iterating over `BMElemSeq` types.
+    """
+
+    def __iter__(self) -> BMIter[GenericType1]:
         """
 
         :return:
-        :rtype: typing.Iterator[GenericType1]
+        :rtype: BMIter[GenericType1]
         """
         ...
 
@@ -758,21 +765,6 @@ class BMFaceSeq:
         """
         ...
 
-    def __len__(self) -> int:
-        """
-
-        :return:
-        :rtype: int
-        """
-        ...
-
-class BMIter:
-    """Internal BMesh type for looping over verts/faces/edges,
-    used for iterating over `BMElemSeq` types.
-    """
-
-    ...
-
 class BMLayerAccessEdge:
     """Exposes custom-data layer attributes."""
 
@@ -980,7 +972,7 @@ class BMLayerCollection:
     :type: bool
     """
 
-    def get(self, key: str, default=None):
+    def get(self, key: str, default: GenericType2 = None) -> BMLayerItem | GenericType2:
         """Returns the value of the layer matching the key or default
         when not found (matches Python's dictionary function of the same name).
 
@@ -988,6 +980,9 @@ class BMLayerCollection:
                 :type key: str
                 :param default: Optional argument for the value to return if
         key is not found.
+                :type default: GenericType2
+                :return:
+                :rtype: BMLayerItem | GenericType2
         """
         ...
 
@@ -1008,11 +1003,11 @@ class BMLayerCollection:
         """
         ...
 
-    def new(self, name: str) -> BMLayerItem:
+    def new(self, name: str | None) -> BMLayerItem:
         """Create a new layer
 
         :param name: Optional name argument (will be made unique).
-        :type name: str
+        :type name: str | None
         :return: The newly created layer.
         :rtype: BMLayerItem
         """
@@ -1052,10 +1047,11 @@ class BMLayerItem:
     :type: str
     """
 
-    def copy_from(self, other):
+    def copy_from(self, other: BMLayerItem):
         """Return a copy of the layer
 
-        :param other: Another layer to copy from.`BMLayerItem`
+        :param other: Another layer to copy from.
+        :type other: BMLayerItem
         """
         ...
 
@@ -1161,87 +1157,62 @@ class BMLoop:
         """
         ...
 
-    def copy_from(self, other):
+    def copy_from(self, other: BMLoop):
         """Copy values from another element of matching type.
 
         :param other:
+        :type other: BMLoop
         """
         ...
 
     def copy_from_face_interp(
-        self, face: BMFace, vert: bool = True, multires: bool = True
+        self, face: BMFace, vert: bool | None = True, multires: bool | None = True
     ):
         """Interpolate the customdata from a face onto this loop (the loops vert should overlap the face).
 
         :param face: The face to interpolate data from.
         :type face: BMFace
         :param vert: When enabled, interpolate the loops vertex data (optional).
-        :type vert: bool
+        :type vert: bool | None
         :param multires: When enabled, interpolate the loops multires data (optional).
-        :type multires: bool
+        :type multires: bool | None
         """
         ...
 
-class BMLoopSeq:
-    layers: BMLayerAccessLoop
-    """ custom-data layers (read-only).
-
-    :type: BMLayerAccessLoop
-    """
-
-    def __getitem__(self, key: int) -> BMLoop:
+    def __getitem__(self, key: BMLayerItem) -> typing.Any:
         """
 
         :param key:
-        :type key: int
+        :type key: BMLayerItem
         :return:
-        :rtype: BMLoop
+        :rtype: typing.Any
         """
         ...
 
-    def __setitem__(self, key: int, value: BMLoop):
+    def __setitem__(self, key: BMLayerItem, value: typing.Any):
         """
 
         :param key:
-        :type key: int
+        :type key: BMLayerItem
         :param value:
-        :type value: BMLoop
+        :type value: typing.Any
         """
         ...
 
-    def __delitem__(self, key: int) -> BMLoop:
+    def __delitem__(self, key: BMLayerItem):
         """
 
         :param key:
-        :type key: int
-        :return:
-        :rtype: BMLoop
-        """
-        ...
-
-    def __iter__(self) -> typing.Iterator[GenericType1]:
-        """
-
-        :return:
-        :rtype: typing.Iterator[GenericType1]
+        :type key: BMLayerItem
         """
         ...
 
-    def __next__(self) -> GenericType1:
-        """
-
-        :return:
-        :rtype: GenericType1
-        """
-        ...
-
-    def __len__(self) -> int:
-        """
+class BMLoopSeq:
+    layers: BMLayerAccessLoop
+    """ custom-data layers (read-only).
 
-        :return:
-        :rtype: int
-        """
-        ...
+    :type: BMLayerAccessLoop
+    """
 
 class BMLoopUV:
     pin_uv: bool
@@ -1262,19 +1233,19 @@ class BMLoopUV:
     :type: bool
     """
 
-    uv: typing.Sequence[float] | mathutils.Vector
+    uv: collections.abc.Sequence[float] | mathutils.Vector
     """ Loops UV (as a 2D Vector).
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
 class BMVert:
     """The BMesh vertex type"""
 
-    co: typing.Sequence[float] | mathutils.Vector
+    co: collections.abc.Sequence[float] | mathutils.Vector
     """ The coordinates for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
     hide: bool
@@ -1331,10 +1302,10 @@ class BMVert:
     :type: list[BMLoop] | BMElemSeq
     """
 
-    normal: typing.Sequence[float] | mathutils.Vector
+    normal: collections.abc.Sequence[float] | mathutils.Vector
     """ The normal for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
     select: bool
@@ -1370,10 +1341,11 @@ class BMVert:
         """
         ...
 
-    def copy_from(self, other):
+    def copy_from(self, other: BMVert):
         """Copy values from another element of matching type.
 
         :param other:
+        :type other: BMVert
         """
         ...
 
@@ -1385,12 +1357,13 @@ class BMVert:
         """
         ...
 
-    def copy_from_vert_interp(self, vert_pair: BMVert, fac):
+    def copy_from_vert_interp(self, vert_pair: BMVert, fac: float):
         """Interpolate the customdata from a vert between 2 other verts.
 
         :param vert_pair: The vert to interpolate data from.
         :type vert_pair: BMVert
         :param fac:
+        :type fac: float
         """
         ...
 
@@ -1419,6 +1392,34 @@ class BMVert:
         """
         ...
 
+    def __getitem__(self, key: BMLayerItem) -> typing.Any:
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        :return:
+        :rtype: typing.Any
+        """
+        ...
+
+    def __setitem__(self, key: BMLayerItem, value: typing.Any):
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        :param value:
+        :type value: typing.Any
+        """
+        ...
+
+    def __delitem__(self, key: BMLayerItem):
+        """
+
+        :param key:
+        :type key: BMLayerItem
+        """
+        ...
+
 class BMVertSeq:
     layers: BMLayerAccessVert
     """ custom-data layers (read-only).
@@ -1436,13 +1437,13 @@ class BMVertSeq:
 
     def new(
         self,
-        co: typing.Sequence[float] | mathutils.Vector = (0.0, 0.0, 0.0),
+        co: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0, 0.0),
         example: BMVert = None,
     ) -> BMVert:
         """Create a new vertex.
 
         :param co: The initial location of the vertex (optional argument).
-        :type co: typing.Sequence[float] | mathutils.Vector
+        :type co: collections.abc.Sequence[float] | mathutils.Vector | None
         :param example: Existing vert to initialize settings.
         :type example: BMVert
         :return: The newly created vertex.
@@ -1450,10 +1451,11 @@ class BMVertSeq:
         """
         ...
 
-    def remove(self, vert):
+    def remove(self, vert: BMVert):
         """Remove a vert.
 
         :param vert:
+        :type vert: BMVert
         """
         ...
 
@@ -1477,39 +1479,11 @@ class BMVertSeq:
         """
         ...
 
-    def __setitem__(self, key: int, value: BMVert):
-        """
-
-        :param key:
-        :type key: int
-        :param value:
-        :type value: BMVert
-        """
-        ...
-
-    def __delitem__(self, key: int) -> BMVert:
-        """
-
-        :param key:
-        :type key: int
-        :return:
-        :rtype: BMVert
-        """
-        ...
-
-    def __iter__(self) -> typing.Iterator[GenericType1]:
+    def __iter__(self) -> BMIter[BMVert]:
         """
 
         :return:
-        :rtype: typing.Iterator[GenericType1]
-        """
-        ...
-
-    def __next__(self) -> GenericType1:
-        """
-
-        :return:
-        :rtype: GenericType1
+        :rtype: BMIter[BMVert]
         """
         ...
 
@@ -1608,8 +1582,8 @@ class BMesh:
     def from_mesh(
         self,
         mesh: bpy.types.Mesh,
-        face_normals=True,
-        vertex_normals=True,
+        face_normals: bool = True,
+        vertex_normals: bool = True,
         use_shape_key: bool = False,
         shape_key_index: int = 0,
     ):
@@ -1618,7 +1592,9 @@ class BMesh:
         :param mesh: The mesh data to load.
         :type mesh: bpy.types.Mesh
         :param face_normals:
+        :type face_normals: bool
         :param vertex_normals:
+        :type vertex_normals: bool
         :param use_shape_key: Use the locations from a shape key.
         :type use_shape_key: bool
         :param shape_key_index: The shape key index to use.
@@ -1629,7 +1605,7 @@ class BMesh:
     def from_object(
         self,
         object: bpy.types.Object,
-        depsgraph,
+        depsgraph: bpy.types.Depsgraph,
         cage: bool = False,
         face_normals: bool = True,
         vertex_normals: bool = True,
@@ -1639,6 +1615,7 @@ class BMesh:
         :param object: The object data to load.
         :type object: bpy.types.Object
         :param depsgraph:
+        :type depsgraph: bpy.types.Depsgraph
         :param cage: Get the mesh as a deformed cage.
         :type cage: bool
         :param face_normals: Calculate face normals.