fake-bpy-module-latest 20251002__py3-none-any.whl → 20260113__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -1,4 +1,16 @@
 """
+SUBSTITUTION REPLACEMENT 'UV_STICKY_SELECT_MODE_REF':
+(bpy.types.ToolSettings.uv_sticky_select_mode which may be passed in directly).
+
+SUBSTITUTION REPLACEMENT 'UV_STICKY_SELECT_MODE_TYPE':
+Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
+
+SUBSTITUTION REPLACEMENT 'UV_SELECT_FLUSH_MODE_NEEDED':
+This function selection-mode independent, typically bmesh.types.BMesh.uv_select_flush_mode should be called afterwards.
+
+SUBSTITUTION REPLACEMENT 'UV_SELECT_SYNC_TO_MESH_NEEDED':
+This function doesn't flush the selection to the mesh, typically bmesh.types.BMesh.uv_select_sync_to_mesh should be called afterwards.
+
 
 --------------------
 
@@ -260,12 +272,17 @@ class BMEdgeSeq:
     def ensure_lookup_table(self) -> None:
         """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: collections.abc.Sequence[BMVert], fallback=None) -> BMEdge:
+    def get(
+        self,
+        verts: collections.abc.Sequence[BMVert],
+        fallback: typing.Any | None = 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.
+        :type fallback: typing.Any | None
         :return: The edge found or None
         :rtype: BMEdge
         """
@@ -289,7 +306,7 @@ class BMEdgeSeq:
     def remove(self, edge: BMEdge) -> None:
         """Remove an edge.
 
-        :param edge:
+        :param edge: The edge to remove.
         :type edge: BMEdge
         """
 
@@ -321,13 +338,13 @@ class BMEdgeSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> list[BMEdge, ...]:
+    def __getitem__(self, key: slice) -> list[BMEdge]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: list[BMEdge, ...]
+        :rtype: list[BMEdge]
         """
 
     def __iter__(self) -> BMIter[BMEdge]:
@@ -397,13 +414,13 @@ class BMElemSeq[_GenericType1]:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> list[_GenericType1, ...]:
+    def __getitem__(self, key: slice) -> list[_GenericType1]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: list[_GenericType1, ...]
+        :rtype: list[_GenericType1]
         """
 
     def __iter__(self) -> BMIter[_GenericType1]:
@@ -477,6 +494,12 @@ class BMFace:
     :type: bool
     """
 
+    uv_select: bool
+    """ UV selected state of this element.
+
+    :type: bool
+    """
+
     verts: typing.Any
     """ Verts of this face, (read-only)."""
 
@@ -597,6 +620,13 @@ class BMFace:
                 :type select: bool
         """
 
+    def uv_select_set(self, select: bool) -> None:
+        """Select the face.
+
+        :param select: Select or de-select.
+        :type select: bool
+        """
+
     def __getitem__[_GenericType1](
         self, key: BMLayerItem[_GenericType1]
     ) -> _GenericType1:
@@ -642,12 +672,17 @@ class BMFaceSeq:
     def ensure_lookup_table(self) -> None:
         """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: collections.abc.Sequence[BMVert], fallback=None) -> BMFace:
+    def get(
+        self,
+        verts: collections.abc.Sequence[BMVert],
+        fallback: typing.Any | None = 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.
+        :type fallback: typing.Any | None
         :return: The face found or None
         :rtype: BMFace
         """
@@ -671,7 +706,7 @@ class BMFaceSeq:
     def remove(self, face: BMFace) -> None:
         """Remove a face.
 
-        :param face:
+        :param face: The face to remove.
         :type face: BMFace
         """
 
@@ -703,13 +738,13 @@ class BMFaceSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> list[BMFace, ...]:
+    def __getitem__(self, key: slice) -> list[BMFace]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: list[BMFace, ...]
+        :rtype: list[BMFace]
         """
 
     def __iter__(self) -> BMIter[BMFace]:
@@ -940,7 +975,7 @@ class BMLayerItem[_GenericType1]:
     """
 
     def copy_from(self, other: typing_extensions.Self) -> None:
-        """Return a copy of the layer
+        """Copy data from another layer.
 
         :param other: Another layer to copy from.
         :type other: typing_extensions.Self
@@ -1012,6 +1047,18 @@ class BMLoop:
     :type: bool
     """
 
+    uv_select_edge: bool
+    """ UV selected state of this element.
+
+    :type: bool
+    """
+
+    uv_select_vert: bool
+    """ UV selected state of this element.
+
+    :type: bool
+    """
+
     vert: BMVert
     """ The loop's vertex (read-only).
 
@@ -1062,6 +1109,20 @@ class BMLoop:
         :type multires: bool
         """
 
+    def uv_select_edge_set(self, select: bool) -> None:
+        """Set the UV edge selection state.
+
+        :param select: Select or de-select.
+        :type select: bool
+        """
+
+    def uv_select_vert_set(self, select: bool) -> None:
+        """Select the UV vertex.
+
+        :param select: Select or de-select.
+        :type select: bool
+        """
+
     def __getitem__[_GenericType1](
         self, key: BMLayerItem[_GenericType1]
     ) -> _GenericType1:
@@ -1109,13 +1170,13 @@ class BMLoopSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> list[BMLoop, ...]:
+    def __getitem__(self, key: slice) -> list[BMLoop]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: list[BMLoop, ...]
+        :rtype: list[BMLoop]
         """
 
     def __iter__(self) -> BMIter[BMLoop]:
@@ -1139,18 +1200,6 @@ class BMLoopUV:
     :type: bool
     """
 
-    select: bool
-    """ UV select state.
-
-    :type: bool
-    """
-
-    select_edge: bool
-    """ UV edge select state.
-
-    :type: bool
-    """
-
     uv: mathutils.Vector
     """ Loops UV (as a 2D Vector).
 
@@ -1269,7 +1318,7 @@ class BMVert:
 
         :param vert_pair: The verts between which to interpolate data from.
         :type vert_pair: collections.abc.Sequence[BMVert]
-        :param fac:
+        :param fac: The interpolation factor.
         :type fac: float
         """
 
@@ -1355,7 +1404,7 @@ class BMVertSeq:
     def remove(self, vert: BMVert) -> None:
         """Remove a vert.
 
-        :param vert:
+        :param vert: The vert to remove.
         :type vert: BMVert
         """
 
@@ -1387,13 +1436,13 @@ class BMVertSeq:
         """
 
     @typing.overload
-    def __getitem__(self, key: slice) -> list[BMVert, ...]:
+    def __getitem__(self, key: slice) -> list[BMVert]:
         """
 
         :param key:
         :type key: slice
         :return:
-        :rtype: list[BMVert, ...]
+        :rtype: list[BMVert]
         """
 
     def __iter__(self) -> BMIter[BMVert]:
@@ -1452,6 +1501,12 @@ class BMesh:
     select_mode: typing.Any
     """ The selection mode, cannot be assigned an empty set."""
 
+    uv_select_sync_valid: bool
+    """ When true, the UV selection has been synchronized. Setting to False means the UV selection will be ignored. While setting to true is supported it is up to the script author to ensure a correct selection state before doing so.
+
+    :type: bool
+    """
+
     verts: BMVertSeq
     """ This meshes vert sequence (read-only).
 
@@ -1500,9 +1555,9 @@ class BMesh:
 
         :param mesh: The mesh data to load.
         :type mesh: bpy.types.Mesh
-        :param face_normals:
+        :param face_normals: Calculate face normals.
         :type face_normals: bool
-        :param vertex_normals:
+        :param vertex_normals: Calculate vertex normals.
         :type vertex_normals: bool
         :param use_shape_key: Use the locations from a shape key.
         :type use_shape_key: bool
@@ -1523,7 +1578,7 @@ class BMesh:
 
         :param object: The object data to load.
         :type object: bpy.types.Object
-        :param depsgraph:
+        :param depsgraph: The dependency graph for evaluated data.
         :type depsgraph: bpy.types.Depsgraph
         :param cage: Get the mesh as a deformed cage.
         :type cage: bool
@@ -1543,8 +1598,12 @@ class BMesh:
         :type select: bool
         """
 
-    def select_flush_mode(self) -> None:
-        """flush selection based on the current mode current `bmesh.types.BMesh.select_mode`."""
+    def select_flush_mode(self, *, flush_down: bool = False) -> None:
+        """Flush selection based on the current mode current `bmesh.types.BMesh.select_mode`.
+
+        :param flush_down: Flush selection down from faces to edges & verts or from edges to verts. This option is ignored when vertex selection mode is enabled.
+        :type flush_down: bool
+        """
 
     def to_mesh(self, mesh: bpy.types.Mesh) -> None:
         """Writes this BMesh data into an existing Mesh data-block.
@@ -1562,7 +1621,96 @@ class BMesh:
     ) -> None:
         """Transform the mesh (optionally filtering flagged data only).
 
-        :param matrix: 4x4x transform matrix.
+        :param matrix: 4x4 transform matrix.
         :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
-        :param filter: Flag to filter vertices..
+        :param filter: Flag to filter vertices.
+        """
+
+    def uv_select_flush(self, select: bool) -> None:
+        """Flush selection from UV vertices to edges & faces independent of the selection mode.
+
+        :param select: Flush selection or de-selected elements.
+        :type select: bool
+        """
+
+    def uv_select_flush_mode(self, *, flush_down: bool = False) -> None:
+        """Flush selection based on the current mode current `BMesh.select_mode`.
+
+        :param flush_down: Flush selection down from faces to edges & verts or from edges to verts. This option is ignored when vertex selection mode is enabled.
+        :type flush_down: bool
+        """
+
+    def uv_select_flush_shared(self, select: bool) -> None:
+        """Flush selection from UV vertices to contiguous UVs independent of the selection mode.
+
+        :param select: Flush selection or de-selected elements.
+        :type select: bool
+        """
+
+    def uv_select_foreach_set(
+        self,
+        select: bool,
+        /,
+        *,
+        loop_verts: collections.abc.Iterable[BMLoop] = (),
+        loop_edges: collections.abc.Iterable[BMLoop] = (),
+        faces: collections.abc.Iterable[BMFace] = (),
+        sticky_select_mode: typing.Literal[
+            "SHARED_LOCATION", "DISABLED", "SHARED_VERTEX"
+        ] = "SHARED_LOCATION",
+    ) -> None:
+        """Set the UV selection state for loop-vertices, loop-edges & faces.This is a close equivalent to selecting in the UV editor.
+
+        :param select: The selection state to set.
+        :type select: bool
+        :param loop_verts: Loop verts to operate on.
+        :type loop_verts: collections.abc.Iterable[BMLoop]
+        :param loop_edges: Loop edges to operate on.
+        :type loop_edges: collections.abc.Iterable[BMLoop]
+        :param faces: Faces to operate on.
+        :type faces: collections.abc.Iterable[BMFace]
+        :param sticky_select_mode: See UV_STICKY_SELECT_MODE_REF.
+        :type sticky_select_mode: typing.Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
+        """
+
+    def uv_select_foreach_set_from_mesh(
+        self,
+        select: bool,
+        /,
+        *,
+        verts: collections.abc.Iterable[BMVert] = (),
+        edges: collections.abc.Iterable[BMEdge] = (),
+        faces: collections.abc.Iterable[BMFace] = (),
+        sticky_select_mode: typing.Literal[
+            "SHARED_LOCATION", "DISABLED", "SHARED_VERTEX"
+        ] = "SHARED_LOCATION",
+    ) -> None:
+        """Select or de-select mesh elements, updating the UV selection.An equivalent to selecting from the 3D viewport for selection operations that support maintaining a synchronized UV selection.
+
+        :param select: The selection state to set.
+        :type select: bool
+        :param verts: Verts to operate on.
+        :type verts: collections.abc.Iterable[BMVert]
+        :param edges: Edges to operate on.
+        :type edges: collections.abc.Iterable[BMEdge]
+        :param faces: Faces to operate on.
+        :type faces: collections.abc.Iterable[BMFace]
+        :param sticky_select_mode: See UV_STICKY_SELECT_MODE_REF.
+        :type sticky_select_mode: typing.Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
+        """
+
+    def uv_select_sync_from_mesh(
+        self,
+        *,
+        sticky_select_mode: typing.Literal[
+            "SHARED_LOCATION", "DISABLED", "SHARED_VERTEX"
+        ] = "SHARED_LOCATION",
+    ) -> None:
+        """Sync selection from mesh to UVs.
+
+        :param sticky_select_mode: Behavior when flushing from the mesh to UV selection UV_STICKY_SELECT_MODE_REF. This should only be used when preparing to create a UV selection.
+        :type sticky_select_mode: typing.Literal['SHARED_LOCATION', 'DISABLED', 'SHARED_VERTEX']
         """
+
+    def uv_select_sync_to_mesh(self) -> None:
+        """Sync selection from UVs to the mesh."""

bmesh/utils/__init__.pyi

@@ -39,11 +39,13 @@ def edge_split(
 def face_flip(faces) -> None:
     """Flip the faces direction."""
 
-def face_join(faces: bmesh.types.BMFace, remove: bool = True) -> bmesh.types.BMFace:
+def face_join(
+    faces: collections.abc.Sequence[bmesh.types.BMFace], remove: bool = True
+) -> bmesh.types.BMFace:
     """Joins a sequence of faces.
 
     :param faces: Sequence of faces.
-    :type faces: bmesh.types.BMFace
+    :type faces: collections.abc.Sequence[bmesh.types.BMFace]
     :param remove: Remove the edges and vertices between the faces.
     :type remove: bool
     :return: The newly created face or None on failure.
@@ -82,7 +84,7 @@ def face_split_edgenet(
 ) -> 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.
+    :param face: The face to split.
     :type face: bmesh.types.BMFace
     :param edgenet: Sequence of edges.
     :type edgenet: collections.abc.Sequence[bmesh.types.BMEdge]
@@ -112,6 +114,21 @@ def loop_separate(loop: bmesh.types.BMLoop) -> bmesh.types.BMVert:
     :rtype: bmesh.types.BMVert
     """
 
+def uv_select_check(
+    bm, /, *, sync: bool = True, flush: bool = False, contiguous: bool = False
+) -> None | dict[str, int]:
+    """Check UV selection state for consistency issues.
+
+    :param sync: Check the data is properly synchronized between UVs and the underlying mesh. Failure to synchronize with the mesh selection may cause tools not to behave properly.
+    :type sync: bool
+    :param flush: Check the selection has been properly flushed between elements (based on the current `BMesh.select_mode`).
+    :type flush: bool
+    :param contiguous: Check connected UVs and edges have a matching selection state.
+    :type contiguous: bool
+    :return: An error dictionary or None when there are no errors found.
+    :rtype: None | dict[str, int]
+    """
+
 def vert_collapse_edge(
     vert: bmesh.types.BMVert, edge: bmesh.types.BMEdge
 ) -> bmesh.types.BMEdge:
@@ -152,14 +169,14 @@ def vert_dissolve(vert: bmesh.types.BMVert) -> bool:
     """
 
 def vert_separate(
-    vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge
+    vert: bmesh.types.BMVert, edges: collections.abc.Sequence[bmesh.types.BMEdge]
 ) -> tuple[bmesh.types.BMVert, ...]:
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
     :type vert: bmesh.types.BMVert
     :param edges: The edges to separated.
-    :type edges: bmesh.types.BMEdge
+    :type edges: collections.abc.Sequence[bmesh.types.BMEdge]
     :return: The newly separated verts (including the vertex passed).
     :rtype: tuple[bmesh.types.BMVert, ...]
     """